/*
 * 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("LeftSquareBracket", "'['");
		tokenNameToValue.put("RightSquareBracket", "']'");
		tokenNameToValue.put("CircumflexAccent", "'^'");
		tokenNameToValue.put("LeftCurlyBracket", "'{'");
		tokenNameToValue.put("VerticalLine", "'|'");
		tokenNameToValue.put("RightCurlyBracket", "'}'");
		tokenNameToValue.put("ExclamationMarkEqualsSign", "'!='");
		tokenNameToValue.put("HyphenMinusGreaterThanSign", "'->'");
		tokenNameToValue.put("FullStopFullStop", "'..'");
		tokenNameToValue.put("ColonHyphenMinus", "':-'");
		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("May", "'may'");
		tokenNameToValue.put("Else", "'else'");
		tokenNameToValue.put("Must", "'must'");
		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("Exists", "'exists'");
		tokenNameToValue.put("Extern", "'extern'");
		tokenNameToValue.put("Forall", "'forall'");
		tokenNameToValue.put("Current", "'current'");
		tokenNameToValue.put("Default", "'default'");
		tokenNameToValue.put("Extends", "'extends'");
		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'");
	}

	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().getStatementsAssignment()); }
		(rule__Problem__StatementsAssignment)*
		{ after(grammarAccess.getProblemAccess().getStatementsAssignment()); }
	)
;
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().getGroup()); }
		(rule__Statement__Group__0)
		{ after(grammarAccess.getStatementAccess().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 entryRuleUnnamedErrorPrediateDefinition
entryRuleUnnamedErrorPrediateDefinition
:
{ before(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); }
	 ruleUnnamedErrorPrediateDefinition
{ after(grammarAccess.getUnnamedErrorPrediateDefinitionRule()); } 
	 EOF 
;

// Rule UnnamedErrorPrediateDefinition
ruleUnnamedErrorPrediateDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getGroup()); }
		(rule__UnnamedErrorPrediateDefinition__Group__0)
		{ after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDefaultDefinition
entryRuleDefaultDefinition
:
{ before(grammarAccess.getDefaultDefinitionRule()); }
	 ruleDefaultDefinition
{ after(grammarAccess.getDefaultDefinitionRule()); } 
	 EOF 
;

// Rule DefaultDefinition
ruleDefaultDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDefaultDefinitionAccess().getGroup()); }
		(rule__DefaultDefinition__Group__0)
		{ after(grammarAccess.getDefaultDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleMetricDefinition
entryRuleMetricDefinition
:
{ before(grammarAccess.getMetricDefinitionRule()); }
	 ruleMetricDefinition
{ after(grammarAccess.getMetricDefinitionRule()); } 
	 EOF 
;

// Rule MetricDefinition
ruleMetricDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getMetricDefinitionAccess().getGroup()); }
		(rule__MetricDefinition__Group__0)
		{ after(grammarAccess.getMetricDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExternPredicateDefinition
entryRuleExternPredicateDefinition
:
{ before(grammarAccess.getExternPredicateDefinitionRule()); }
	 ruleExternPredicateDefinition
{ after(grammarAccess.getExternPredicateDefinitionRule()); } 
	 EOF 
;

// Rule ExternPredicateDefinition
ruleExternPredicateDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExternPredicateDefinitionAccess().getGroup()); }
		(rule__ExternPredicateDefinition__Group__0)
		{ after(grammarAccess.getExternPredicateDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExternMetricDefinition
entryRuleExternMetricDefinition
:
{ before(grammarAccess.getExternMetricDefinitionRule()); }
	 ruleExternMetricDefinition
{ after(grammarAccess.getExternMetricDefinitionRule()); } 
	 EOF 
;

// Rule ExternMetricDefinition
ruleExternMetricDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExternMetricDefinitionAccess().getGroup()); }
		(rule__ExternMetricDefinition__Group__0)
		{ after(grammarAccess.getExternMetricDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExternAggregatorDefinition
entryRuleExternAggregatorDefinition
:
{ before(grammarAccess.getExternAggregatorDefinitionRule()); }
	 ruleExternAggregatorDefinition
{ after(grammarAccess.getExternAggregatorDefinitionRule()); } 
	 EOF 
;

// Rule ExternAggregatorDefinition
ruleExternAggregatorDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExternAggregatorDefinitionAccess().getGroup()); }
		(rule__ExternAggregatorDefinition__Group__0)
		{ after(grammarAccess.getExternAggregatorDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExternDatatypeDefinition
entryRuleExternDatatypeDefinition
:
{ before(grammarAccess.getExternDatatypeDefinitionRule()); }
	 ruleExternDatatypeDefinition
{ after(grammarAccess.getExternDatatypeDefinitionRule()); } 
	 EOF 
;

// Rule ExternDatatypeDefinition
ruleExternDatatypeDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExternDatatypeDefinitionAccess().getGroup()); }
		(rule__ExternDatatypeDefinition__Group__0)
		{ after(grammarAccess.getExternDatatypeDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleVariable
entryRuleVariable
:
{ before(grammarAccess.getVariableRule()); }
	 ruleVariable
{ after(grammarAccess.getVariableRule()); } 
	 EOF 
;

// Rule Variable
ruleVariable 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getVariableAccess().getGroup()); }
		(rule__Variable__Group__0)
		{ after(grammarAccess.getVariableAccess().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 entryRuleIfElse
entryRuleIfElse
:
{ before(grammarAccess.getIfElseRule()); }
	 ruleIfElse
{ after(grammarAccess.getIfElseRule()); } 
	 EOF 
;

// Rule IfElse
ruleIfElse 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getIfElseAccess().getGroup()); }
		(rule__IfElse__Group__0)
		{ after(grammarAccess.getIfElseAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLet
entryRuleLet
:
{ before(grammarAccess.getLetRule()); }
	 ruleLet
{ after(grammarAccess.getLetRule()); } 
	 EOF 
;

// Rule Let
ruleLet 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLetAccess().getGroup()); }
		(rule__Let__Group__0)
		{ after(grammarAccess.getLetAccess().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 entryRuleImplicationExpression
entryRuleImplicationExpression
:
{ before(grammarAccess.getImplicationExpressionRule()); }
	 ruleImplicationExpression
{ after(grammarAccess.getImplicationExpressionRule()); } 
	 EOF 
;

// Rule ImplicationExpression
ruleImplicationExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getImplicationExpressionAccess().getGroup()); }
		(rule__ImplicationExpression__Group__0)
		{ after(grammarAccess.getImplicationExpressionAccess().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 entryRuleAggregationExpression
entryRuleAggregationExpression
:
{ before(grammarAccess.getAggregationExpressionRule()); }
	 ruleAggregationExpression
{ after(grammarAccess.getAggregationExpressionRule()); } 
	 EOF 
;

// Rule AggregationExpression
ruleAggregationExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAggregationExpressionAccess().getAlternatives()); }
		(rule__AggregationExpression__Alternatives)
		{ after(grammarAccess.getAggregationExpressionAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLocalVariables
entryRuleLocalVariables
:
{ before(grammarAccess.getLocalVariablesRule()); }
	 ruleLocalVariables
{ after(grammarAccess.getLocalVariablesRule()); } 
	 EOF 
;

// Rule LocalVariables
ruleLocalVariables 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLocalVariablesAccess().getGroup()); }
		(rule__LocalVariables__Group__0)
		{ after(grammarAccess.getLocalVariablesAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

// Rule QuantifiedExpression
ruleQuantifiedExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getQuantifiedExpressionAccess().getGroup()); }
		(rule__QuantifiedExpression__Group__0)
		{ after(grammarAccess.getQuantifiedExpressionAccess().getGroup()); }
	)
;
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 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().getBodyAssignment()); }
		(rule__ExpressionArgument__BodyAssignment)
		{ after(grammarAccess.getExpressionArgumentAccess().getBodyAssignment()); }
	)
;
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 entryRuleTypedArgument
entryRuleTypedArgument
:
{ before(grammarAccess.getTypedArgumentRule()); }
	 ruleTypedArgument
{ after(grammarAccess.getTypedArgumentRule()); } 
	 EOF 
;

// Rule TypedArgument
ruleTypedArgument 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getTypedArgumentAccess().getGroup()); }
		(rule__TypedArgument__Group__0)
		{ after(grammarAccess.getTypedArgumentAccess().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().getReferredAssignment()); }
		(rule__Reference__ReferredAssignment)
		{ after(grammarAccess.getReferenceAccess().getReferredAssignment()); }
	)
;
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 entryRuleNumericLiteral
entryRuleNumericLiteral
:
{ before(grammarAccess.getNumericLiteralRule()); }
	 ruleNumericLiteral
{ after(grammarAccess.getNumericLiteralRule()); } 
	 EOF 
;

// Rule NumericLiteral
ruleNumericLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getNumericLiteralAccess().getValueAssignment()); }
		(rule__NumericLiteral__ValueAssignment)
		{ after(grammarAccess.getNumericLiteralAccess().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 entryRuleEmptyIntervalLiteral
entryRuleEmptyIntervalLiteral
:
{ before(grammarAccess.getEmptyIntervalLiteralRule()); }
	 ruleEmptyIntervalLiteral
{ after(grammarAccess.getEmptyIntervalLiteralRule()); } 
	 EOF 
;

// Rule EmptyIntervalLiteral
ruleEmptyIntervalLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getEmptyIntervalLiteralAccess().getGroup()); }
		(rule__EmptyIntervalLiteral__Group__0)
		{ after(grammarAccess.getEmptyIntervalLiteralAccess().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 entryRuleClassDefinition
entryRuleClassDefinition
:
{ before(grammarAccess.getClassDefinitionRule()); }
	 ruleClassDefinition
{ after(grammarAccess.getClassDefinitionRule()); } 
	 EOF 
;

// Rule ClassDefinition
ruleClassDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getClassDefinitionAccess().getGroup()); }
		(rule__ClassDefinition__Group__0)
		{ after(grammarAccess.getClassDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleMemberDefinition
entryRuleMemberDefinition
:
{ before(grammarAccess.getMemberDefinitionRule()); }
	 ruleMemberDefinition
{ after(grammarAccess.getMemberDefinitionRule()); } 
	 EOF 
;

// Rule MemberDefinition
ruleMemberDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getMemberDefinitionAccess().getGroup()); }
		(rule__MemberDefinition__Group__0)
		{ after(grammarAccess.getMemberDefinitionAccess().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 entryRuleManyMultiplicity
entryRuleManyMultiplicity
:
{ before(grammarAccess.getManyMultiplicityRule()); }
	 ruleManyMultiplicity
{ after(grammarAccess.getManyMultiplicityRule()); } 
	 EOF 
;

// Rule ManyMultiplicity
ruleManyMultiplicity 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getManyMultiplicityAccess().getGroup()); }
		(rule__ManyMultiplicity__Group__0)
		{ after(grammarAccess.getManyMultiplicityAccess().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 entryRuleScopeDefinition
entryRuleScopeDefinition
:
{ before(grammarAccess.getScopeDefinitionRule()); }
	 ruleScopeDefinition
{ after(grammarAccess.getScopeDefinitionRule()); } 
	 EOF 
;

// Rule ScopeDefinition
ruleScopeDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getScopeDefinitionAccess().getAlternatives()); }
		(rule__ScopeDefinition__Alternatives)
		{ after(grammarAccess.getScopeDefinitionAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExactScopeDefinition
entryRuleExactScopeDefinition
:
{ before(grammarAccess.getExactScopeDefinitionRule()); }
	 ruleExactScopeDefinition
{ after(grammarAccess.getExactScopeDefinitionRule()); } 
	 EOF 
;

// Rule ExactScopeDefinition
ruleExactScopeDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExactScopeDefinitionAccess().getGroup()); }
		(rule__ExactScopeDefinition__Group__0)
		{ after(grammarAccess.getExactScopeDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleBoundedScopeDefinition
entryRuleBoundedScopeDefinition
:
{ before(grammarAccess.getBoundedScopeDefinitionRule()); }
	 ruleBoundedScopeDefinition
{ after(grammarAccess.getBoundedScopeDefinitionRule()); } 
	 EOF 
;

// Rule BoundedScopeDefinition
ruleBoundedScopeDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup()); }
		(rule__BoundedScopeDefinition__Group__0)
		{ after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLowerBoundedScopeDefinition
entryRuleLowerBoundedScopeDefinition
:
{ before(grammarAccess.getLowerBoundedScopeDefinitionRule()); }
	 ruleLowerBoundedScopeDefinition
{ after(grammarAccess.getLowerBoundedScopeDefinitionRule()); } 
	 EOF 
;

// Rule LowerBoundedScopeDefinition
ruleLowerBoundedScopeDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup()); }
		(rule__LowerBoundedScopeDefinition__Group__0)
		{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleObjectiveDefinition
entryRuleObjectiveDefinition
:
{ before(grammarAccess.getObjectiveDefinitionRule()); }
	 ruleObjectiveDefinition
{ after(grammarAccess.getObjectiveDefinitionRule()); } 
	 EOF 
;

// Rule ObjectiveDefinition
ruleObjectiveDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getObjectiveDefinitionAccess().getGroup()); }
		(rule__ObjectiveDefinition__Group__0)
		{ after(grammarAccess.getObjectiveDefinitionAccess().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 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().getAlternatives()); }
		(rule__QualifiedName__Alternatives)
		{ after(grammarAccess.getQualifiedNameAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
	myHiddenTokenState.restore();
}

// Rule ImplicationOperator
ruleImplicationOperator
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getImplicationOperatorAccess().getIMPLIESEnumLiteralDeclaration()); }
		(EqualsSignGreaterThanSign)
		{ after(grammarAccess.getImplicationOperatorAccess().getIMPLIESEnumLiteralDeclaration()); }
	)
;
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 UnaryOp
ruleUnaryOp
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnaryOpAccess().getAlternatives()); }
		(rule__UnaryOp__Alternatives)
		{ after(grammarAccess.getUnaryOpAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Rule Quantifier
ruleQuantifier
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifierAccess().getAlternatives()); }
		(rule__Quantifier__Alternatives)
		{ after(grammarAccess.getQuantifierAccess().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_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); }
		ruleAssertionOrDefinition
		{ after(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); }
		rulePredicateDefinition
		{ after(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_0_1()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); }
		ruleUnnamedErrorPrediateDefinition
		{ after(grammarAccess.getStatementAccess().getUnnamedErrorPrediateDefinitionParserRuleCall_0_2()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); }
		ruleDefaultDefinition
		{ after(grammarAccess.getStatementAccess().getDefaultDefinitionParserRuleCall_0_3()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_4()); }
		ruleMetricDefinition
		{ after(grammarAccess.getStatementAccess().getMetricDefinitionParserRuleCall_0_4()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_5()); }
		ruleExternPredicateDefinition
		{ after(grammarAccess.getStatementAccess().getExternPredicateDefinitionParserRuleCall_0_5()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); }
		ruleExternMetricDefinition
		{ after(grammarAccess.getStatementAccess().getExternMetricDefinitionParserRuleCall_0_6()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getExternAggregatorDefinitionParserRuleCall_0_7()); }
		ruleExternAggregatorDefinition
		{ after(grammarAccess.getStatementAccess().getExternAggregatorDefinitionParserRuleCall_0_7()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getExternDatatypeDefinitionParserRuleCall_0_8()); }
		ruleExternDatatypeDefinition
		{ after(grammarAccess.getStatementAccess().getExternDatatypeDefinitionParserRuleCall_0_8()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_9()); }
		ruleClassDefinition
		{ after(grammarAccess.getStatementAccess().getClassDefinitionParserRuleCall_0_9()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_10()); }
		ruleScopeDefinition
		{ after(grammarAccess.getStatementAccess().getScopeDefinitionParserRuleCall_0_10()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_11()); }
		ruleObjectiveDefinition
		{ after(grammarAccess.getStatementAccess().getObjectiveDefinitionParserRuleCall_0_11()); }
	)
;
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__Expression__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); }
		ruleIfElse
		{ after(grammarAccess.getExpressionAccess().getIfElseParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getExpressionAccess().getLetParserRuleCall_1()); }
		ruleLet
		{ after(grammarAccess.getExpressionAccess().getLetParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getExpressionAccess().getImplicationExpressionParserRuleCall_2()); }
		ruleImplicationExpression
		{ after(grammarAccess.getExpressionAccess().getImplicationExpressionParserRuleCall_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().getAggregationExpressionParserRuleCall_0()); }
		ruleAggregationExpression
		{ after(grammarAccess.getUnaryExpressionAccess().getAggregationExpressionParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getGroup_1()); }
		(rule__UnaryExpression__Group_1__0)
		{ after(grammarAccess.getUnaryExpressionAccess().getGroup_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AggregationExpression__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); }
		ruleAtomicExpression
		{ after(grammarAccess.getAggregationExpressionAccess().getAtomicExpressionParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getAggregationExpressionAccess().getQuantifiedExpressionParserRuleCall_1()); }
		ruleQuantifiedExpression
		{ after(grammarAccess.getAggregationExpressionAccess().getQuantifiedExpressionParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_2()); }
		ruleAggregation
		{ after(grammarAccess.getAggregationExpressionAccess().getAggregationParserRuleCall_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__Call__Alternatives_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0()); }
		(rule__Call__TransitiveClosureAssignment_1_0)
		{ after(grammarAccess.getCallAccess().getTransitiveClosureAssignment_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1()); }
		(rule__Call__ReflexiveTransitiveClosureAssignment_1_1)
		{ after(grammarAccess.getCallAccess().getReflexiveTransitiveClosureAssignment_1_1()); }
	)
;
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().getTypedArgumentParserRuleCall_2()); }
		ruleTypedArgument
		{ after(grammarAccess.getArgumentAccess().getTypedArgumentParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); }
		ruleTypedStarArgument
		{ after(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Literal__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); }
		ruleLogicLiteral
		{ after(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); }
		ruleNumericLiteral
		{ after(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); }
		ruleInfinityLiteral
		{ after(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); }
		ruleEmptyIntervalLiteral
		{ after(grammarAccess.getLiteralAccess().getEmptyIntervalLiteralParserRuleCall_3()); }
	)
	|
	(
		{ before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); }
		ruleStringLiteral
		{ after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Multiplicity__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_0()); }
		ruleManyMultiplicity
		{ after(grammarAccess.getMultiplicityAccess().getManyMultiplicityParserRuleCall_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__ScopeDefinition__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); }
		ruleExactScopeDefinition
		{ after(grammarAccess.getScopeDefinitionAccess().getExactScopeDefinitionParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); }
		ruleBoundedScopeDefinition
		{ after(grammarAccess.getScopeDefinitionAccess().getBoundedScopeDefinitionParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); }
		ruleLowerBoundedScopeDefinition
		{ after(grammarAccess.getScopeDefinitionAccess().getLowerBoundedScopeDefinitionParserRuleCall_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Alternatives_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0()); }
		(rule__BoundedScopeDefinition__Group_1_0__0)
		{ after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1()); }
		(rule__BoundedScopeDefinition__Group_1_1__0)
		{ after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScopeDefinition__Alternatives_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_0()); }
		(rule__LowerBoundedScopeDefinition__Group_1_0__0)
		{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getGroup_1_1()); }
		(rule__LowerBoundedScopeDefinition__Group_1_1__0)
		{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().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__QualifiedName__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQualifiedNameAccess().getGroup_0()); }
		(rule__QualifiedName__Group_0__0)
		{ after(grammarAccess.getQualifiedNameAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); }
		RULE_QUOTED_ID
		{ after(grammarAccess.getQualifiedNameAccess().getQUOTED_IDTerminalRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComparisonOperator__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); }
		(EqualsSignEqualsSign)
		{ after(grammarAccess.getComparisonOperatorAccess().getEQEnumLiteralDeclaration_0()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); }
		(ExclamationMarkEqualsSign)
		{ after(grammarAccess.getComparisonOperatorAccess().getNOT_EQEnumLiteralDeclaration_1()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); }
		(LessThanSign)
		{ after(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); }
		(LessThanSignEqualsSign)
		{ after(grammarAccess.getComparisonOperatorAccess().getLESS_EQEnumLiteralDeclaration_3()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); }
		(GreaterThanSign)
		{ after(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_5()); }
		(GreaterThanSignEqualsSign)
		{ after(grammarAccess.getComparisonOperatorAccess().getGREATER_EQEnumLiteralDeclaration_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().getADDEnumLiteralDeclaration_0()); }
		(PlusSign)
		{ after(grammarAccess.getAdditiveBinaryOperatorAccess().getADDEnumLiteralDeclaration_0()); }
	)
	|
	(
		{ before(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); }
		(HyphenMinus)
		{ after(grammarAccess.getAdditiveBinaryOperatorAccess().getSUBEnumLiteralDeclaration_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

rule__UnaryOp__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); }
		(ExclamationMark)
		{ after(grammarAccess.getUnaryOpAccess().getNEGEnumLiteralDeclaration_0()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); }
		(PlusSign)
		{ after(grammarAccess.getUnaryOpAccess().getPLUSEnumLiteralDeclaration_1()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); }
		(HyphenMinus)
		{ after(grammarAccess.getUnaryOpAccess().getMINUSEnumLiteralDeclaration_2()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); }
		(May)
		{ after(grammarAccess.getUnaryOpAccess().getMAYEnumLiteralDeclaration_3()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); }
		(Must)
		{ after(grammarAccess.getUnaryOpAccess().getMUSTEnumLiteralDeclaration_4()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); }
		(Current)
		{ after(grammarAccess.getUnaryOpAccess().getCURRENTEnumLiteralDeclaration_5()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Quantifier__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifierAccess().getEXISTSEnumLiteralDeclaration_0()); }
		(Exists)
		{ after(grammarAccess.getQuantifierAccess().getEXISTSEnumLiteralDeclaration_0()); }
	)
	|
	(
		{ before(grammarAccess.getQuantifierAccess().getFORALLEnumLiteralDeclaration_1()); }
		(Forall)
		{ after(grammarAccess.getQuantifierAccess().getFORALLEnumLiteralDeclaration_1()); }
	)
	|
	(
		{ before(grammarAccess.getQuantifierAccess().getCOUNTEnumLiteralDeclaration_2()); }
		(Count)
		{ after(grammarAccess.getQuantifierAccess().getCOUNTEnumLiteralDeclaration_2()); }
	)
;
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().getMINIMIZEEnumLiteralDeclaration_0()); }
		(Minimize)
		{ after(grammarAccess.getObjectiveKindAccess().getMINIMIZEEnumLiteralDeclaration_0()); }
	)
	|
	(
		{ before(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); }
		(Maximize)
		{ after(grammarAccess.getObjectiveKindAccess().getMAXIMIZEEnumLiteralDeclaration_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Statement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Statement__Group__0__Impl
	rule__Statement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Statement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStatementAccess().getAlternatives_0()); }
	(rule__Statement__Alternatives_0)
	{ after(grammarAccess.getStatementAccess().getAlternatives_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Statement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Statement__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Statement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_1()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getStatementAccess().getFULL_STOPTerminalRuleCall_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
;
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_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().getInterpretationBodyAction_1_0_0()); }
	()
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getInterpretationBodyAction_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

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

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

rule__AssertionOrDefinition__Group_1_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group_1_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_2()); }
	(rule__AssertionOrDefinition__RangeAssignment_1_0_2)
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_2()); }
)
;
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().getMetricDefinitionHeadAction_1_2_0()); }
	()
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_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().getEqualsSignKeyword_1_2_1()); }
	EqualsSign
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getEqualsSignKeyword_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
;
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_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__UnnamedErrorPrediateDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnnamedErrorPrediateDefinition__Group__0__Impl
	rule__UnnamedErrorPrediateDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__UnnamedErrorPrediateDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnnamedErrorPrediateDefinition__Group__1__Impl
	rule__UnnamedErrorPrediateDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPrediateDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListAssignment_1()); }
	(rule__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1)
	{ after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPrediateDefinition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnnamedErrorPrediateDefinition__Group__2__Impl
	rule__UnnamedErrorPrediateDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

rule__UnnamedErrorPrediateDefinition__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnnamedErrorPrediateDefinition__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPrediateDefinition__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyAssignment_3()); }
	(rule__UnnamedErrorPrediateDefinition__BodyAssignment_3)
	{ after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__DefaultDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DefaultDefinition__Group__0__Impl
	rule__DefaultDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__DefaultDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DefaultDefinition__Group__1__Impl
	rule__DefaultDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDefaultDefinitionAccess().getHeadAssignment_1()); }
	(rule__DefaultDefinition__HeadAssignment_1)
	{ after(grammarAccess.getDefaultDefinitionAccess().getHeadAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultDefinition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DefaultDefinition__Group__2__Impl
	rule__DefaultDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultDefinition__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); }
	Colon
	{ after(grammarAccess.getDefaultDefinitionAccess().getColonKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultDefinition__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DefaultDefinition__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultDefinition__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDefaultDefinitionAccess().getRangeAssignment_3()); }
	(rule__DefaultDefinition__RangeAssignment_3)
	{ after(grammarAccess.getDefaultDefinitionAccess().getRangeAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__MetricDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MetricDefinition__Group__0__Impl
	rule__MetricDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MetricDefinition__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMetricDefinitionAccess().getTypeAssignment_0()); }
	(rule__MetricDefinition__TypeAssignment_0)
	{ after(grammarAccess.getMetricDefinitionAccess().getTypeAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__MetricDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MetricDefinition__Group__1__Impl
	rule__MetricDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__MetricDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMetricDefinitionAccess().getHeadAssignment_1()); }
	(rule__MetricDefinition__HeadAssignment_1)
	{ after(grammarAccess.getMetricDefinitionAccess().getHeadAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__MetricDefinition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MetricDefinition__Group__2__Impl
	rule__MetricDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

rule__MetricDefinition__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MetricDefinition__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MetricDefinition__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMetricDefinitionAccess().getBodyAssignment_3()); }
	(rule__MetricDefinition__BodyAssignment_3)
	{ after(grammarAccess.getMetricDefinitionAccess().getBodyAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExternPredicateDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternPredicateDefinition__Group__0__Impl
	rule__ExternPredicateDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ExternPredicateDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternPredicateDefinition__Group__1__Impl
	rule__ExternPredicateDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternPredicateDefinitionAccess().getNameAssignment_1()); }
	(rule__ExternPredicateDefinition__NameAssignment_1)
	{ after(grammarAccess.getExternPredicateDefinitionAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDefinition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternPredicateDefinition__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDefinition__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternPredicateDefinitionAccess().getArgumentListAssignment_2()); }
	(rule__ExternPredicateDefinition__ArgumentListAssignment_2)
	{ after(grammarAccess.getExternPredicateDefinitionAccess().getArgumentListAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExternMetricDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternMetricDefinition__Group__0__Impl
	rule__ExternMetricDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ExternMetricDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternMetricDefinition__Group__1__Impl
	rule__ExternMetricDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternMetricDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternMetricDefinitionAccess().getTypeAssignment_1()); }
	(rule__ExternMetricDefinition__TypeAssignment_1)
	{ after(grammarAccess.getExternMetricDefinitionAccess().getTypeAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternMetricDefinition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternMetricDefinition__Group__2__Impl
	rule__ExternMetricDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternMetricDefinition__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternMetricDefinitionAccess().getNameAssignment_2()); }
	(rule__ExternMetricDefinition__NameAssignment_2)
	{ after(grammarAccess.getExternMetricDefinitionAccess().getNameAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternMetricDefinition__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternMetricDefinition__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternMetricDefinition__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternMetricDefinitionAccess().getArgumentListAssignment_3()); }
	(rule__ExternMetricDefinition__ArgumentListAssignment_3)
	{ after(grammarAccess.getExternMetricDefinitionAccess().getArgumentListAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExternAggregatorDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregatorDefinition__Group__0__Impl
	rule__ExternAggregatorDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ExternAggregatorDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregatorDefinition__Group__1__Impl
	rule__ExternAggregatorDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregatorDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternAggregatorDefinitionAccess().getTypeAssignment_1()); }
	(rule__ExternAggregatorDefinition__TypeAssignment_1)
	{ after(grammarAccess.getExternAggregatorDefinitionAccess().getTypeAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregatorDefinition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregatorDefinition__Group__2__Impl
	rule__ExternAggregatorDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregatorDefinition__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternAggregatorDefinitionAccess().getNameAssignment_2()); }
	(rule__ExternAggregatorDefinition__NameAssignment_2)
	{ after(grammarAccess.getExternAggregatorDefinitionAccess().getNameAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregatorDefinition__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregatorDefinition__Group__3__Impl
	rule__ExternAggregatorDefinition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ExternAggregatorDefinition__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregatorDefinition__Group__4__Impl
	rule__ExternAggregatorDefinition__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregatorDefinition__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternAggregatorDefinitionAccess().getInputTypeAssignment_4()); }
	(rule__ExternAggregatorDefinition__InputTypeAssignment_4)
	{ after(grammarAccess.getExternAggregatorDefinitionAccess().getInputTypeAssignment_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregatorDefinition__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregatorDefinition__Group__5__Impl
	rule__ExternAggregatorDefinition__Group__6
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ExternAggregatorDefinition__Group__6
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregatorDefinition__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

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


rule__ExternDatatypeDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternDatatypeDefinition__Group__0__Impl
	rule__ExternDatatypeDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ExternDatatypeDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternDatatypeDefinition__Group__1__Impl
	rule__ExternDatatypeDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ExternDatatypeDefinition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternDatatypeDefinition__Group__2__Impl
	rule__ExternDatatypeDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDefinition__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternDatatypeDefinitionAccess().getNameAssignment_2()); }
	(rule__ExternDatatypeDefinition__NameAssignment_2)
	{ after(grammarAccess.getExternDatatypeDefinitionAccess().getNameAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDefinition__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternDatatypeDefinition__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDefinition__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternDatatypeDefinitionAccess().getGroup_3()); }
	(rule__ExternDatatypeDefinition__Group_3__0)
	{ after(grammarAccess.getExternDatatypeDefinitionAccess().getGroup_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExternDatatypeDefinition__Group_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternDatatypeDefinition__Group_3__0__Impl
	rule__ExternDatatypeDefinition__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ExternDatatypeDefinition__Group_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternDatatypeDefinition__Group_3__1__Impl
	rule__ExternDatatypeDefinition__Group_3__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDefinition__Group_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesAssignment_3_1()); }
	(rule__ExternDatatypeDefinition__SupertypesAssignment_3_1)
	{ after(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesAssignment_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDefinition__Group_3__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternDatatypeDefinition__Group_3__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDefinition__Group_3__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternDatatypeDefinitionAccess().getGroup_3_2()); }
	(rule__ExternDatatypeDefinition__Group_3_2__0)*
	{ after(grammarAccess.getExternDatatypeDefinitionAccess().getGroup_3_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExternDatatypeDefinition__Group_3_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternDatatypeDefinition__Group_3_2__0__Impl
	rule__ExternDatatypeDefinition__Group_3_2__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ExternDatatypeDefinition__Group_3_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternDatatypeDefinition__Group_3_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDefinition__Group_3_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesAssignment_3_2_1()); }
	(rule__ExternDatatypeDefinition__SupertypesAssignment_3_2_1)
	{ after(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesAssignment_3_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Variable__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Variable__Group__0__Impl
	rule__Variable__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Variable__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariableAccess().getTypeAssignment_0()); }
	(rule__Variable__TypeAssignment_0)?
	{ after(grammarAccess.getVariableAccess().getTypeAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Variable__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Variable__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Variable__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariableAccess().getNameAssignment_1()); }
	(rule__Variable__NameAssignment_1)
	{ after(grammarAccess.getVariableAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IfElse__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IfElse__Group__0__Impl
	rule__IfElse__Group__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__IfElse__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IfElse__Group__1__Impl
	rule__IfElse__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__IfElse__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIfElseAccess().getConditionAssignment_1()); }
	(rule__IfElse__ConditionAssignment_1)
	{ after(grammarAccess.getIfElseAccess().getConditionAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IfElse__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IfElse__Group__2__Impl
	rule__IfElse__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

rule__IfElse__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IfElse__Group__3__Impl
	rule__IfElse__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__IfElse__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIfElseAccess().getThenAssignment_3()); }
	(rule__IfElse__ThenAssignment_3)
	{ after(grammarAccess.getIfElseAccess().getThenAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IfElse__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IfElse__Group__4__Impl
	rule__IfElse__Group__5
;
finally {
	restoreStackSize(stackSize);
}

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

rule__IfElse__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IfElse__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IfElse__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIfElseAccess().getElseAssignment_5()); }
	(rule__IfElse__ElseAssignment_5)
	{ after(grammarAccess.getIfElseAccess().getElseAssignment_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Let__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Let__Group__0__Impl
	rule__Let__Group__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__Let__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Let__Group__1__Impl
	rule__Let__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Let__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetAccess().getBindingsAssignment_1()); }
	(rule__Let__BindingsAssignment_1)
	{ after(grammarAccess.getLetAccess().getBindingsAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Let__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Let__Group__2__Impl
	rule__Let__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Let__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetAccess().getGroup_2()); }
	(rule__Let__Group_2__0)*
	{ after(grammarAccess.getLetAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Let__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Let__Group__3__Impl
	rule__Let__Group__4
;
finally {
	restoreStackSize(stackSize);
}

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

rule__Let__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Let__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Let__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetAccess().getBodyAssignment_4()); }
	(rule__Let__BodyAssignment_4)
	{ after(grammarAccess.getLetAccess().getBodyAssignment_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Let__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Let__Group_2__0__Impl
	rule__Let__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__Let__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Let__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Let__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetAccess().getBindingsAssignment_2_1()); }
	(rule__Let__BindingsAssignment_2_1)
	{ after(grammarAccess.getLetAccess().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().getVariableAssignment_0()); }
	(rule__LetBinding__VariableAssignment_0)
	{ after(grammarAccess.getLetBindingAccess().getVariableAssignment_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().getEqualsSignKeyword_1()); }
	EqualsSign
	{ after(grammarAccess.getLetBindingAccess().getEqualsSignKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

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

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


rule__ImplicationExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ImplicationExpression__Group__0__Impl
	rule__ImplicationExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ImplicationExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getImplicationExpressionAccess().getDisjunctiveExpressionParserRuleCall_0()); }
	ruleDisjunctiveExpression
	{ after(grammarAccess.getImplicationExpressionAccess().getDisjunctiveExpressionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ImplicationExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ImplicationExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ImplicationExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getImplicationExpressionAccess().getGroup_1()); }
	(rule__ImplicationExpression__Group_1__0)?
	{ after(grammarAccess.getImplicationExpressionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ImplicationExpression__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ImplicationExpression__Group_1__0__Impl
	rule__ImplicationExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ImplicationExpression__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ImplicationExpression__Group_1__1__Impl
	rule__ImplicationExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ImplicationExpression__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getImplicationExpressionAccess().getOpAssignment_1_1()); }
	(rule__ImplicationExpression__OpAssignment_1_1)
	{ after(grammarAccess.getImplicationExpressionAccess().getOpAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ImplicationExpression__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ImplicationExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ImplicationExpression__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getImplicationExpressionAccess().getRightAssignment_1_2()); }
	(rule__ImplicationExpression__RightAssignment_1_2)
	{ after(grammarAccess.getImplicationExpressionAccess().getRightAssignment_1_2()); }
)
;
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().getComparisonLeftAction_1_0()); }
	()
	{ after(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_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().getTypeAssignment_1_2()); }
	(rule__CastExpression__TypeAssignment_1_2)
	{ after(grammarAccess.getCastExpressionAccess().getTypeAssignment_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__LocalVariables__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalVariables__Group__0__Impl
	rule__LocalVariables__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalVariables__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalVariablesAccess().getLocalVariablesAction_0()); }
	()
	{ after(grammarAccess.getLocalVariablesAccess().getLocalVariablesAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalVariables__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalVariables__Group__1__Impl
	rule__LocalVariables__Group__2
;
finally {
	restoreStackSize(stackSize);
}

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

rule__LocalVariables__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalVariables__Group__2__Impl
	rule__LocalVariables__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalVariables__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalVariablesAccess().getGroup_2()); }
	(rule__LocalVariables__Group_2__0)?
	{ after(grammarAccess.getLocalVariablesAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalVariables__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalVariables__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalVariables__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalVariablesAccess().getRightSquareBracketKeyword_3()); }
	RightSquareBracket
	{ after(grammarAccess.getLocalVariablesAccess().getRightSquareBracketKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LocalVariables__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalVariables__Group_2__0__Impl
	rule__LocalVariables__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalVariables__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalVariablesAccess().getVariablesAssignment_2_0()); }
	(rule__LocalVariables__VariablesAssignment_2_0)
	{ after(grammarAccess.getLocalVariablesAccess().getVariablesAssignment_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalVariables__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalVariables__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalVariables__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalVariablesAccess().getGroup_2_1()); }
	(rule__LocalVariables__Group_2_1__0)*
	{ after(grammarAccess.getLocalVariablesAccess().getGroup_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LocalVariables__Group_2_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalVariables__Group_2_1__0__Impl
	rule__LocalVariables__Group_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__LocalVariables__Group_2_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalVariables__Group_2_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalVariables__Group_2_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalVariablesAccess().getVariablesAssignment_2_1_1()); }
	(rule__LocalVariables__VariablesAssignment_2_1_1)
	{ after(grammarAccess.getLocalVariablesAccess().getVariablesAssignment_2_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QuantifiedExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group__0__Impl
	rule__QuantifiedExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getQuantifierAssignment_0()); }
	(rule__QuantifiedExpression__QuantifierAssignment_0)
	{ after(grammarAccess.getQuantifiedExpressionAccess().getQuantifierAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group__1__Impl
	rule__QuantifiedExpression__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getLocalVariablesAssignment_1()); }
	(rule__QuantifiedExpression__LocalVariablesAssignment_1)?
	{ after(grammarAccess.getQuantifiedExpressionAccess().getLocalVariablesAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group__2__Impl
	rule__QuantifiedExpression__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getLeftCurlyBracketKeyword_2()); }
	LeftCurlyBracket
	{ after(grammarAccess.getQuantifiedExpressionAccess().getLeftCurlyBracketKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group__3__Impl
	rule__QuantifiedExpression__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getBodyAssignment_3()); }
	(rule__QuantifiedExpression__BodyAssignment_3)
	{ after(grammarAccess.getQuantifiedExpressionAccess().getBodyAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getRightCurlyBracketKeyword_4()); }
	RightCurlyBracket
	{ after(grammarAccess.getQuantifiedExpressionAccess().getRightCurlyBracketKeyword_4()); }
)
;
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().getLocalVariablesAssignment_1()); }
	(rule__Aggregation__LocalVariablesAssignment_1)?
	{ after(grammarAccess.getAggregationAccess().getLocalVariablesAssignment_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().getLeftCurlyBracketKeyword_2()); }
	LeftCurlyBracket
	{ after(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_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().getBodyAssignment_3()); }
	(rule__Aggregation__BodyAssignment_3)
	{ after(grammarAccess.getAggregationAccess().getBodyAssignment_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().getGroup_4()); }
	(rule__Aggregation__Group_4__0)?
	{ after(grammarAccess.getAggregationAccess().getGroup_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__Aggregation__Group_4__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Aggregation__Group_4__0__Impl
	rule__Aggregation__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__Aggregation__Group_4__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Aggregation__Group_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__Group_4__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAggregationAccess().getConditionAssignment_4_1()); }
	(rule__Aggregation__ConditionAssignment_4_1)
	{ after(grammarAccess.getAggregationAccess().getConditionAssignment_4_1()); }
)
;
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
	rule__Call__Group__2
;
finally {
	restoreStackSize(stackSize);
}

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

rule__Call__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Call__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Call__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCallAccess().getArgumentListAssignment_2()); }
	(rule__Call__ArgumentListAssignment_2)
	{ after(grammarAccess.getCallAccess().getArgumentListAssignment_2()); }
)
;
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__TypedArgument__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TypedArgument__Group__0__Impl
	rule__TypedArgument__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedArgument__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTypedArgumentAccess().getTypeAssignment_0()); }
	(rule__TypedArgument__TypeAssignment_0)
	{ after(grammarAccess.getTypedArgumentAccess().getTypeAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedArgument__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TypedArgument__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedArgument__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTypedArgumentAccess().getVariableAssignment_1()); }
	(rule__TypedArgument__VariableAssignment_1)
	{ after(grammarAccess.getTypedArgumentAccess().getVariableAssignment_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().getTypeAssignment_0()); }
	(rule__TypedStarArgument__TypeAssignment_0)
	{ after(grammarAccess.getTypedStarArgumentAccess().getTypeAssignment_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__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().getFullStopFullStopKeyword_2()); }
	FullStopFullStop
	{ after(grammarAccess.getIntervalAccess().getFullStopFullStopKeyword_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__EmptyIntervalLiteral__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EmptyIntervalLiteral__Group__0__Impl
	rule__EmptyIntervalLiteral__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EmptyIntervalLiteral__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0()); }
	()
	{ after(grammarAccess.getEmptyIntervalLiteralAccess().getEmptyIntervalLiteralAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EmptyIntervalLiteral__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EmptyIntervalLiteral__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

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


rule__ClassDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDefinition__Group__0__Impl
	rule__ClassDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDefinitionAccess().getAbstractAssignment_0()); }
	(rule__ClassDefinition__AbstractAssignment_0)?
	{ after(grammarAccess.getClassDefinitionAccess().getAbstractAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDefinition__Group__1__Impl
	rule__ClassDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ClassDefinition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDefinition__Group__2__Impl
	rule__ClassDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDefinitionAccess().getNameAssignment_2()); }
	(rule__ClassDefinition__NameAssignment_2)
	{ after(grammarAccess.getClassDefinitionAccess().getNameAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDefinition__Group__3__Impl
	rule__ClassDefinition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDefinitionAccess().getGroup_3()); }
	(rule__ClassDefinition__Group_3__0)?
	{ after(grammarAccess.getClassDefinitionAccess().getGroup_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDefinition__Group__4__Impl
	rule__ClassDefinition__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); }
	LeftCurlyBracket
	{ after(grammarAccess.getClassDefinitionAccess().getLeftCurlyBracketKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDefinition__Group__5__Impl
	rule__ClassDefinition__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDefinitionAccess().getMembersAssignment_5()); }
	(rule__ClassDefinition__MembersAssignment_5)*
	{ after(grammarAccess.getClassDefinitionAccess().getMembersAssignment_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group__6
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDefinition__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

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


rule__ClassDefinition__Group_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDefinition__Group_3__0__Impl
	rule__ClassDefinition__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ClassDefinition__Group_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDefinition__Group_3__1__Impl
	rule__ClassDefinition__Group_3__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_1()); }
	(rule__ClassDefinition__SuperclassesAssignment_3_1)
	{ after(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group_3__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDefinition__Group_3__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group_3__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDefinitionAccess().getGroup_3_2()); }
	(rule__ClassDefinition__Group_3_2__0)*
	{ after(grammarAccess.getClassDefinitionAccess().getGroup_3_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ClassDefinition__Group_3_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDefinition__Group_3_2__0__Impl
	rule__ClassDefinition__Group_3_2__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ClassDefinition__Group_3_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDefinition__Group_3_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__Group_3_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_2_1()); }
	(rule__ClassDefinition__SuperclassesAssignment_3_2_1)
	{ after(grammarAccess.getClassDefinitionAccess().getSuperclassesAssignment_3_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__MemberDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MemberDefinition__Group__0__Impl
	rule__MemberDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMemberDefinitionAccess().getContainmentAssignment_0()); }
	(rule__MemberDefinition__ContainmentAssignment_0)?
	{ after(grammarAccess.getMemberDefinitionAccess().getContainmentAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MemberDefinition__Group__1__Impl
	rule__MemberDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMemberDefinitionAccess().getTypeAssignment_1()); }
	(rule__MemberDefinition__TypeAssignment_1)
	{ after(grammarAccess.getMemberDefinitionAccess().getTypeAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MemberDefinition__Group__2__Impl
	rule__MemberDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMemberDefinitionAccess().getMultiplicityAssignment_2()); }
	(rule__MemberDefinition__MultiplicityAssignment_2)?
	{ after(grammarAccess.getMemberDefinitionAccess().getMultiplicityAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MemberDefinition__Group__3__Impl
	rule__MemberDefinition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMemberDefinitionAccess().getNameAssignment_3()); }
	(rule__MemberDefinition__NameAssignment_3)
	{ after(grammarAccess.getMemberDefinitionAccess().getNameAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MemberDefinition__Group__4__Impl
	rule__MemberDefinition__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMemberDefinitionAccess().getGroup_4()); }
	(rule__MemberDefinition__Group_4__0)?
	{ after(grammarAccess.getMemberDefinitionAccess().getGroup_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MemberDefinition__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

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


rule__MemberDefinition__Group_4__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MemberDefinition__Group_4__0__Impl
	rule__MemberDefinition__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__MemberDefinition__Group_4__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MemberDefinition__Group_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__Group_4__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMemberDefinitionAccess().getOppositeAssignment_4_1()); }
	(rule__MemberDefinition__OppositeAssignment_4_1)
	{ after(grammarAccess.getMemberDefinitionAccess().getOppositeAssignment_4_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ManyMultiplicity__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ManyMultiplicity__Group__0__Impl
	rule__ManyMultiplicity__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ManyMultiplicity__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0()); }
	()
	{ after(grammarAccess.getManyMultiplicityAccess().getManyMultiplicityAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ManyMultiplicity__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ManyMultiplicity__Group__1__Impl
	rule__ManyMultiplicity__Group__2
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ManyMultiplicity__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ManyMultiplicity__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ManyMultiplicity__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getManyMultiplicityAccess().getRightSquareBracketKeyword_2()); }
	RightSquareBracket
	{ after(grammarAccess.getManyMultiplicityAccess().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().getMultiplicityAssignment_1()); }
	(rule__ExactMultiplicity__MultiplicityAssignment_1)
	{ after(grammarAccess.getExactMultiplicityAccess().getMultiplicityAssignment_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().getFullStopFullStopKeyword_2()); }
	FullStopFullStop
	{ after(grammarAccess.getBoundedMultiplicityAccess().getFullStopFullStopKeyword_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__ExactScopeDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExactScopeDefinition__Group__0__Impl
	rule__ExactScopeDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ExactScopeDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExactScopeDefinition__Group__1__Impl
	rule__ExactScopeDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScopeDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExactScopeDefinitionAccess().getTypeAssignment_1()); }
	(rule__ExactScopeDefinition__TypeAssignment_1)
	{ after(grammarAccess.getExactScopeDefinitionAccess().getTypeAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScopeDefinition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExactScopeDefinition__Group__2__Impl
	rule__ExactScopeDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ExactScopeDefinition__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExactScopeDefinition__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScopeDefinition__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExactScopeDefinitionAccess().getExactScopeAssignment_3()); }
	(rule__ExactScopeDefinition__ExactScopeAssignment_3)
	{ after(grammarAccess.getExactScopeDefinitionAccess().getExactScopeAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BoundedScopeDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group__0__Impl
	rule__BoundedScopeDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__BoundedScopeDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeDefinitionAccess().getAlternatives_1()); }
	(rule__BoundedScopeDefinition__Alternatives_1)
	{ after(grammarAccess.getBoundedScopeDefinitionAccess().getAlternatives_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BoundedScopeDefinition__Group_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group_1_0__0__Impl
	rule__BoundedScopeDefinition__Group_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0_0()); }
	(rule__BoundedScopeDefinition__Group_1_0_0__0)?
	{ after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group_1_0__1__Impl
	rule__BoundedScopeDefinition__Group_1_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_0_1()); }
	(rule__BoundedScopeDefinition__TypeAssignment_1_0_1)
	{ after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group_1_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group_1_0__2__Impl
	rule__BoundedScopeDefinition__Group_1_0__3
;
finally {
	restoreStackSize(stackSize);
}

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

rule__BoundedScopeDefinition__Group_1_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group_1_0__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group_1_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_0_3()); }
	(rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3)
	{ after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BoundedScopeDefinition__Group_1_0_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group_1_0_0__0__Impl
	rule__BoundedScopeDefinition__Group_1_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group_1_0_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0_0()); }
	(rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0)
	{ after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group_1_0_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group_1_0_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

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


rule__BoundedScopeDefinition__Group_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group_1_1__0__Impl
	rule__BoundedScopeDefinition__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_1_0()); }
	(rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0)
	{ after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundAssignment_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group_1_1__1__Impl
	rule__BoundedScopeDefinition__Group_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

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

rule__BoundedScopeDefinition__Group_1_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group_1_1__2__Impl
	rule__BoundedScopeDefinition__Group_1_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group_1_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_1_2()); }
	(rule__BoundedScopeDefinition__TypeAssignment_1_1_2)
	{ after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeAssignment_1_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group_1_1__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group_1_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group_1_1__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1_3()); }
	(rule__BoundedScopeDefinition__Group_1_1_3__0)?
	{ after(grammarAccess.getBoundedScopeDefinitionAccess().getGroup_1_1_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BoundedScopeDefinition__Group_1_1_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group_1_1_3__0__Impl
	rule__BoundedScopeDefinition__Group_1_1_3__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__BoundedScopeDefinition__Group_1_1_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScopeDefinition__Group_1_1_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__Group_1_1_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_3_1()); }
	(rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1)
	{ after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LowerBoundedScopeDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScopeDefinition__Group__0__Impl
	rule__LowerBoundedScopeDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__LowerBoundedScopeDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScopeDefinition__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScopeDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getAlternatives_1()); }
	(rule__LowerBoundedScopeDefinition__Alternatives_1)
	{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getAlternatives_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LowerBoundedScopeDefinition__Group_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl
	rule__LowerBoundedScopeDefinition__Group_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScopeDefinition__Group_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0()); }
	(rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0)
	{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScopeDefinition__Group_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScopeDefinition__Group_1_0__1__Impl
	rule__LowerBoundedScopeDefinition__Group_1_0__2
;
finally {
	restoreStackSize(stackSize);
}

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

rule__LowerBoundedScopeDefinition__Group_1_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScopeDefinition__Group_1_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_0_2()); }
	(rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2)
	{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LowerBoundedScopeDefinition__Group_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl
	rule__LowerBoundedScopeDefinition__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScopeDefinition__Group_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_1_0()); }
	(rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0)
	{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeAssignment_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScopeDefinition__Group_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScopeDefinition__Group_1_1__1__Impl
	rule__LowerBoundedScopeDefinition__Group_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

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

rule__LowerBoundedScopeDefinition__Group_1_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScopeDefinition__Group_1_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_2()); }
	(rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2)
	{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundAssignment_1_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ObjectiveDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObjectiveDefinition__Group__0__Impl
	rule__ObjectiveDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ObjectiveDefinition__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObjectiveDefinitionAccess().getKindAssignment_0()); }
	(rule__ObjectiveDefinition__KindAssignment_0)
	{ after(grammarAccess.getObjectiveDefinitionAccess().getKindAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObjectiveDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObjectiveDefinition__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ObjectiveDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObjectiveDefinitionAccess().getObjectiveAssignment_1()); }
	(rule__ObjectiveDefinition__ObjectiveAssignment_1)
	{ after(grammarAccess.getObjectiveDefinitionAccess().getObjectiveAssignment_1()); }
)
;
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
;
finally {
	restoreStackSize(stackSize);
}

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


rule__Real__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Real__Group_1__0__Impl
	rule__Real__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

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

rule__Real__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Real__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

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


rule__QualifiedName__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QualifiedName__Group_0__0__Impl
	rule__QualifiedName__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QualifiedName__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); }
	RULE_ID
	{ after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QualifiedName__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QualifiedName__Group_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QualifiedName__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQualifiedNameAccess().getGroup_0_1()); }
	(rule__QualifiedName__Group_0_1__0)*
	{ after(grammarAccess.getQualifiedNameAccess().getGroup_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QualifiedName__Group_0_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QualifiedName__Group_0_1__0__Impl
	rule__QualifiedName__Group_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QualifiedName__Group_0_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); }
	FullStop
	{ after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_0_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QualifiedName__Group_0_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QualifiedName__Group_0_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QualifiedName__Group_0_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); }
	RULE_ID
	{ after(grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


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

rule__AssertionOrDefinition__RangeAssignment_1_0_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_2_0()); }
		ruleExpression
		{ after(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_2_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__UnnamedErrorPrediateDefinition__ArgumentListAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
		ruleArgumentList
		{ after(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

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

rule__DefaultDefinition__RangeAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); }
		ruleExpression
		{ after(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__MetricDefinition__TypeAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMetricDefinitionAccess().getTypeNamedElementCrossReference_0_0()); }
		(
			{ before(grammarAccess.getMetricDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getMetricDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
		)
		{ after(grammarAccess.getMetricDefinitionAccess().getTypeNamedElementCrossReference_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

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

rule__ExternPredicateDefinition__NameAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternPredicateDefinitionAccess().getNameQualifiedNameParserRuleCall_1_0()); }
		ruleQualifiedName
		{ after(grammarAccess.getExternPredicateDefinitionAccess().getNameQualifiedNameParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDefinition__ArgumentListAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternPredicateDefinitionAccess().getArgumentListArgumentListParserRuleCall_2_0()); }
		ruleArgumentList
		{ after(grammarAccess.getExternPredicateDefinitionAccess().getArgumentListArgumentListParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternMetricDefinition__TypeAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternMetricDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
		(
			{ before(grammarAccess.getExternMetricDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getExternMetricDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getExternMetricDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

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

rule__ExternAggregatorDefinition__TypeAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternAggregatorDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
		(
			{ before(grammarAccess.getExternAggregatorDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getExternAggregatorDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getExternAggregatorDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ExternAggregatorDefinition__InputTypeAssignment_4
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternAggregatorDefinitionAccess().getInputTypeNamedElementCrossReference_4_0()); }
		(
			{ before(grammarAccess.getExternAggregatorDefinitionAccess().getInputTypeNamedElementQualifiedNameParserRuleCall_4_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getExternAggregatorDefinitionAccess().getInputTypeNamedElementQualifiedNameParserRuleCall_4_0_1()); }
		)
		{ after(grammarAccess.getExternAggregatorDefinitionAccess().getInputTypeNamedElementCrossReference_4_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ExternDatatypeDefinition__SupertypesAssignment_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementCrossReference_3_1_0()); }
		(
			{ before(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); }
		)
		{ after(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementCrossReference_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDefinition__SupertypesAssignment_3_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementCrossReference_3_2_1_0()); }
		(
			{ before(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); }
		)
		{ after(grammarAccess.getExternDatatypeDefinitionAccess().getSupertypesNamedElementCrossReference_3_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Variable__TypeAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariableAccess().getTypeNamedElementCrossReference_0_0()); }
		(
			{ before(grammarAccess.getVariableAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getVariableAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
		)
		{ after(grammarAccess.getVariableAccess().getTypeNamedElementCrossReference_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

rule__IfElse__ConditionAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); }
		ruleExpression
		{ after(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

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

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

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

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

rule__LetBinding__VariableAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLetBindingAccess().getVariableVariableParserRuleCall_0_0()); }
		ruleVariable
		{ after(grammarAccess.getLetBindingAccess().getVariableVariableParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

rule__ImplicationExpression__OpAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getImplicationExpressionAccess().getOpImplicationOperatorEnumRuleCall_1_1_0()); }
		ruleImplicationOperator
		{ after(grammarAccess.getImplicationExpressionAccess().getOpImplicationOperatorEnumRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ImplicationExpression__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getImplicationExpressionAccess().getRightImplicationExpressionParserRuleCall_1_2_0()); }
		ruleImplicationExpression
		{ after(grammarAccess.getImplicationExpressionAccess().getRightImplicationExpressionParserRuleCall_1_2_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__TypeAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCastExpressionAccess().getTypeNamedElementCrossReference_1_2_0()); }
		(
			{ before(grammarAccess.getCastExpressionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_2_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getCastExpressionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_2_0_1()); }
		)
		{ after(grammarAccess.getCastExpressionAccess().getTypeNamedElementCrossReference_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

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

rule__LocalVariables__VariablesAssignment_2_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLocalVariablesAccess().getVariablesVariableParserRuleCall_2_0_0()); }
		ruleVariable
		{ after(grammarAccess.getLocalVariablesAccess().getVariablesVariableParserRuleCall_2_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalVariables__VariablesAssignment_2_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLocalVariablesAccess().getVariablesVariableParserRuleCall_2_1_1_0()); }
		ruleVariable
		{ after(grammarAccess.getLocalVariablesAccess().getVariablesVariableParserRuleCall_2_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__QuantifierAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifiedExpressionAccess().getQuantifierQuantifierEnumRuleCall_0_0()); }
		ruleQuantifier
		{ after(grammarAccess.getQuantifiedExpressionAccess().getQuantifierQuantifierEnumRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__LocalVariablesAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifiedExpressionAccess().getLocalVariablesLocalVariablesParserRuleCall_1_0()); }
		ruleLocalVariables
		{ after(grammarAccess.getQuantifiedExpressionAccess().getLocalVariablesLocalVariablesParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

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

rule__Aggregation__LocalVariablesAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAggregationAccess().getLocalVariablesLocalVariablesParserRuleCall_1_0()); }
		ruleLocalVariables
		{ after(grammarAccess.getAggregationAccess().getLocalVariablesLocalVariablesParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

rule__Aggregation__ConditionAssignment_4_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_1_0()); }
		ruleExpression
		{ after(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_1_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__TransitiveClosureAssignment_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); }
		RULE_TRANSITIVE_CLOSURE
		{ after(grammarAccess.getCallAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Call__ReflexiveTransitiveClosureAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); }
		RULE_REFLEXIVE_TRANSITIVE_CLOSURE
		{ after(grammarAccess.getCallAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Call__ArgumentListAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_0()); }
		ruleArgumentList
		{ after(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_2_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__BodyAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); }
		ruleComparisonExpression
		{ after(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedArgument__TypeAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
		(
			{ before(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
		)
		{ after(grammarAccess.getTypedArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedArgument__VariableAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); }
		(
			{ before(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getTypedArgumentAccess().getVariableNamedElementCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedStarArgument__TypeAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
		(
			{ before(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1()); }
		)
		{ after(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementCrossReference_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Reference__ReferredAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); }
		(
			{ before(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1()); }
		)
		{ after(grammarAccess.getReferenceAccess().getReferredNamedElementCrossReference_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

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

rule__Interval__UpperBoundAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0()); }
		ruleExpression
		{ after(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_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__NumericLiteral__ValueAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0()); }
		ruleReal
		{ after(grammarAccess.getNumericLiteralAccess().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__ClassDefinition__AbstractAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); }
		(
			{ before(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); }
			Abstract
			{ after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); }
		)
		{ after(grammarAccess.getClassDefinitionAccess().getAbstractAbstractKeyword_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__NameAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); }
		RULE_ID
		{ after(grammarAccess.getClassDefinitionAccess().getNameIDTerminalRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__SuperclassesAssignment_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); }
		(
			{ before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_1_0_1()); }
		)
		{ after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__SuperclassesAssignment_3_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); }
		(
			{ before(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementQualifiedNameParserRuleCall_3_2_1_0_1()); }
		)
		{ after(grammarAccess.getClassDefinitionAccess().getSuperclassesNamedElementCrossReference_3_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDefinition__MembersAssignment_5
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); }
		ruleMemberDefinition
		{ after(grammarAccess.getClassDefinitionAccess().getMembersMemberDefinitionParserRuleCall_5_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__ContainmentAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); }
		(
			{ before(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); }
			Contains
			{ after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); }
		)
		{ after(grammarAccess.getMemberDefinitionAccess().getContainmentContainsKeyword_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__TypeAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
		(
			{ before(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getMemberDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__MultiplicityAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); }
		ruleMultiplicity
		{ after(grammarAccess.getMemberDefinitionAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__NameAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); }
		RULE_ID
		{ after(grammarAccess.getMemberDefinitionAccess().getNameIDTerminalRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberDefinition__OppositeAssignment_4_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); }
		(
			{ before(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementQualifiedNameParserRuleCall_4_1_0_1()); }
		)
		{ after(grammarAccess.getMemberDefinitionAccess().getOppositeNamedElementCrossReference_4_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactMultiplicity__MultiplicityAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0()); }
		ruleUpperMultiplicty
		{ after(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_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__ExactScopeDefinition__TypeAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
		(
			{ before(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScopeDefinition__ExactScopeAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); }
		RULE_INT
		{ after(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__LowerBoundAssignment_1_0_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); }
		RULE_INT
		{ after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__TypeAssignment_1_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); }
		(
			{ before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1_0_1()); }
		)
		{ after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__UpperBoundAssignment_1_0_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); }
		RULE_INT
		{ after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__UpperBoundAssignment_1_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); }
		RULE_INT
		{ after(grammarAccess.getBoundedScopeDefinitionAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__TypeAssignment_1_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); }
		(
			{ before(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_2_0_1()); }
		)
		{ after(grammarAccess.getBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScopeDefinition__LowerBoundAssignment_1_1_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); }
		RULE_INT
		{ after(grammarAccess.getBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); }
		RULE_INT
		{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScopeDefinition__TypeAssignment_1_0_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); }
		(
			{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_2_0_1()); }
		)
		{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_0_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScopeDefinition__TypeAssignment_1_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); }
		(
			{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_1_0_0_1()); }
		)
		{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getTypeNamedElementCrossReference_1_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScopeDefinition__LowerBoundAssignment_1_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); }
		RULE_INT
		{ after(grammarAccess.getLowerBoundedScopeDefinitionAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObjectiveDefinition__KindAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); }
		ruleObjectiveKind
		{ after(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObjectiveDefinition__ObjectiveAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); }
		ruleExpression
		{ after(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}