/*
* generated by Xtext
*/
grammar InternalMscript;

options {
	superClass=AbstractInternalContentAssistParser;
	backtrack=true;
	
}

@lexer::header {
package org.eclipselabs.mscript.language.ui.contentassist.antlr.internal;

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

@parser::header {
package org.eclipselabs.mscript.language.ui.contentassist.antlr.internal; 

import java.io.InputStream;
import org.eclipse.xtext.*;
import org.eclipse.xtext.parser.*;
import org.eclipse.xtext.parser.impl.*;
import org.eclipse.xtext.parsetree.*;
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.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA;
import org.eclipselabs.mscript.language.services.MscriptGrammarAccess;

}

@parser::members {
 
 	private MscriptGrammarAccess grammarAccess;
 	
    public void setGrammarAccess(MscriptGrammarAccess grammarAccess) {
    	this.grammarAccess = grammarAccess;
    }
    
    @Override
    protected Grammar getGrammar() {
    	return grammarAccess.getGrammar();
    }
    
    @Override
    protected String getValueForTokenName(String tokenName) {
    	return tokenName;
    }

}




// Entry rule entryRuleModule
entryRuleModule 
:
{ before(grammarAccess.getModuleRule()); }
	 ruleModule
{ after(grammarAccess.getModuleRule()); } 
	 EOF 
;

// Rule Module
ruleModule
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getModuleAccess().getDefinitionsAssignment()); }
(rule__Module__DefinitionsAssignment)*
{ after(grammarAccess.getModuleAccess().getDefinitionsAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleDefinition
entryRuleDefinition 
:
{ before(grammarAccess.getDefinitionRule()); }
	 ruleDefinition
{ after(grammarAccess.getDefinitionRule()); } 
	 EOF 
;

// Rule Definition
ruleDefinition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getDefinitionAccess().getAlternatives()); }
(rule__Definition__Alternatives)
{ after(grammarAccess.getDefinitionAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleDataTypeDefinition
entryRuleDataTypeDefinition 
:
{ before(grammarAccess.getDataTypeDefinitionRule()); }
	 ruleDataTypeDefinition
{ after(grammarAccess.getDataTypeDefinitionRule()); } 
	 EOF 
;

// Rule DataTypeDefinition
ruleDataTypeDefinition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getDataTypeDefinitionAccess().getAlternatives()); }
(rule__DataTypeDefinition__Alternatives)
{ after(grammarAccess.getDataTypeDefinitionAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleEnumerationDefinition
entryRuleEnumerationDefinition 
:
{ before(grammarAccess.getEnumerationDefinitionRule()); }
	 ruleEnumerationDefinition
{ after(grammarAccess.getEnumerationDefinitionRule()); } 
	 EOF 
;

// Rule EnumerationDefinition
ruleEnumerationDefinition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getEnumerationDefinitionAccess().getGroup()); }
(rule__EnumerationDefinition__Group__0)
{ after(grammarAccess.getEnumerationDefinitionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleEnumerationLiteralDeclaration
entryRuleEnumerationLiteralDeclaration 
:
{ before(grammarAccess.getEnumerationLiteralDeclarationRule()); }
	 ruleEnumerationLiteralDeclaration
{ after(grammarAccess.getEnumerationLiteralDeclarationRule()); } 
	 EOF 
;

// Rule EnumerationLiteralDeclaration
ruleEnumerationLiteralDeclaration
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getEnumerationLiteralDeclarationAccess().getNameAssignment()); }
(rule__EnumerationLiteralDeclaration__NameAssignment)
{ after(grammarAccess.getEnumerationLiteralDeclarationAccess().getNameAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleTypeAliasDefinition
entryRuleTypeAliasDefinition 
:
{ before(grammarAccess.getTypeAliasDefinitionRule()); }
	 ruleTypeAliasDefinition
{ after(grammarAccess.getTypeAliasDefinitionRule()); } 
	 EOF 
;

// Rule TypeAliasDefinition
ruleTypeAliasDefinition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getTypeAliasDefinitionAccess().getGroup()); }
(rule__TypeAliasDefinition__Group__0)
{ after(grammarAccess.getTypeAliasDefinitionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleRecordDefinition
entryRuleRecordDefinition 
:
{ before(grammarAccess.getRecordDefinitionRule()); }
	 ruleRecordDefinition
{ after(grammarAccess.getRecordDefinitionRule()); } 
	 EOF 
;

// Rule RecordDefinition
ruleRecordDefinition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRecordDefinitionAccess().getGroup()); }
(rule__RecordDefinition__Group__0)
{ after(grammarAccess.getRecordDefinitionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



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

// Rule RecordFieldDeclaration
ruleRecordFieldDeclaration
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRecordFieldDeclarationAccess().getGroup()); }
(rule__RecordFieldDeclaration__Group__0)
{ after(grammarAccess.getRecordFieldDeclarationAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



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

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

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleTemplateParameterDeclaration
entryRuleTemplateParameterDeclaration 
:
{ before(grammarAccess.getTemplateParameterDeclarationRule()); }
	 ruleTemplateParameterDeclaration
{ after(grammarAccess.getTemplateParameterDeclarationRule()); } 
	 EOF 
;

// Rule TemplateParameterDeclaration
ruleTemplateParameterDeclaration
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getTemplateParameterDeclarationAccess().getNameAssignment()); }
(rule__TemplateParameterDeclaration__NameAssignment)
{ after(grammarAccess.getTemplateParameterDeclarationAccess().getNameAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleInputParameterDeclaration
entryRuleInputParameterDeclaration 
:
{ before(grammarAccess.getInputParameterDeclarationRule()); }
	 ruleInputParameterDeclaration
{ after(grammarAccess.getInputParameterDeclarationRule()); } 
	 EOF 
;

// Rule InputParameterDeclaration
ruleInputParameterDeclaration
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getInputParameterDeclarationAccess().getNameAssignment()); }
(rule__InputParameterDeclaration__NameAssignment)
{ after(grammarAccess.getInputParameterDeclarationAccess().getNameAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOutputParameterDeclaration
entryRuleOutputParameterDeclaration 
:
{ before(grammarAccess.getOutputParameterDeclarationRule()); }
	 ruleOutputParameterDeclaration
{ after(grammarAccess.getOutputParameterDeclarationRule()); } 
	 EOF 
;

// Rule OutputParameterDeclaration
ruleOutputParameterDeclaration
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOutputParameterDeclarationAccess().getNameAssignment()); }
(rule__OutputParameterDeclaration__NameAssignment)
{ after(grammarAccess.getOutputParameterDeclarationAccess().getNameAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleCheck
entryRuleCheck 
:
{ before(grammarAccess.getCheckRule()); }
	 ruleCheck
{ after(grammarAccess.getCheckRule()); } 
	 EOF 
;

// Rule Check
ruleCheck
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getCheckAccess().getGroup()); }
(rule__Check__Group__0)
{ after(grammarAccess.getCheckAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleAssertion
entryRuleAssertion 
:
{ before(grammarAccess.getAssertionRule()); }
	 ruleAssertion
{ after(grammarAccess.getAssertionRule()); } 
	 EOF 
;

// Rule Assertion
ruleAssertion
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getAssertionAccess().getGroup()); }
(rule__Assertion__Group__0)
{ after(grammarAccess.getAssertionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleStateVariableDeclaration
entryRuleStateVariableDeclaration 
:
{ before(grammarAccess.getStateVariableDeclarationRule()); }
	 ruleStateVariableDeclaration
{ after(grammarAccess.getStateVariableDeclarationRule()); } 
	 EOF 
;

// Rule StateVariableDeclaration
ruleStateVariableDeclaration
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getStateVariableDeclarationAccess().getGroup()); }
(rule__StateVariableDeclaration__Group__0)
{ after(grammarAccess.getStateVariableDeclarationAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleFunctionObjectDeclaration
entryRuleFunctionObjectDeclaration 
:
{ before(grammarAccess.getFunctionObjectDeclarationRule()); }
	 ruleFunctionObjectDeclaration
{ after(grammarAccess.getFunctionObjectDeclarationRule()); } 
	 EOF 
;

// Rule FunctionObjectDeclaration
ruleFunctionObjectDeclaration
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getGroup()); }
(rule__FunctionObjectDeclaration__Group__0)
{ after(grammarAccess.getFunctionObjectDeclarationAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleEquation
entryRuleEquation 
:
{ before(grammarAccess.getEquationRule()); }
	 ruleEquation
{ after(grammarAccess.getEquationRule()); } 
	 EOF 
;

// Rule Equation
ruleEquation
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getEquationAccess().getGroup()); }
(rule__Equation__Group__0)
{ after(grammarAccess.getEquationAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleDataTypeSpecifier
entryRuleDataTypeSpecifier 
:
{ before(grammarAccess.getDataTypeSpecifierRule()); }
	 ruleDataTypeSpecifier
{ after(grammarAccess.getDataTypeSpecifierRule()); } 
	 EOF 
;

// Rule DataTypeSpecifier
ruleDataTypeSpecifier
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getDataTypeSpecifierAccess().getAlternatives()); }
(rule__DataTypeSpecifier__Alternatives)
{ after(grammarAccess.getDataTypeSpecifierAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRulePrimitiveType
entryRulePrimitiveType 
:
{ before(grammarAccess.getPrimitiveTypeRule()); }
	 rulePrimitiveType
{ after(grammarAccess.getPrimitiveTypeRule()); } 
	 EOF 
;

// Rule PrimitiveType
rulePrimitiveType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getAlternatives()); }
(rule__PrimitiveType__Alternatives)
{ after(grammarAccess.getPrimitiveTypeAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleNumericType
entryRuleNumericType 
:
{ before(grammarAccess.getNumericTypeRule()); }
	 ruleNumericType
{ after(grammarAccess.getNumericTypeRule()); } 
	 EOF 
;

// Rule NumericType
ruleNumericType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getNumericTypeAccess().getAlternatives()); }
(rule__NumericType__Alternatives)
{ after(grammarAccess.getNumericTypeAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleRealType
entryRuleRealType 
:
{ before(grammarAccess.getRealTypeRule()); }
	 ruleRealType
{ after(grammarAccess.getRealTypeRule()); } 
	 EOF 
;

// Rule RealType
ruleRealType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRealTypeAccess().getGroup()); }
(rule__RealType__Group__0)
{ after(grammarAccess.getRealTypeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleIntegerType
entryRuleIntegerType 
:
{ before(grammarAccess.getIntegerTypeRule()); }
	 ruleIntegerType
{ after(grammarAccess.getIntegerTypeRule()); } 
	 EOF 
;

// Rule IntegerType
ruleIntegerType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getIntegerTypeAccess().getGroup()); }
(rule__IntegerType__Group__0)
{ after(grammarAccess.getIntegerTypeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleComplexType
entryRuleComplexType 
:
{ before(grammarAccess.getComplexTypeRule()); }
	 ruleComplexType
{ after(grammarAccess.getComplexTypeRule()); } 
	 EOF 
;

// Rule ComplexType
ruleComplexType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getComplexTypeAccess().getGroup()); }
(rule__ComplexType__Group__0)
{ after(grammarAccess.getComplexTypeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleGaussianType
entryRuleGaussianType 
:
{ before(grammarAccess.getGaussianTypeRule()); }
	 ruleGaussianType
{ after(grammarAccess.getGaussianTypeRule()); } 
	 EOF 
;

// Rule GaussianType
ruleGaussianType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getGaussianTypeAccess().getGroup()); }
(rule__GaussianType__Group__0)
{ after(grammarAccess.getGaussianTypeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleBooleanType
entryRuleBooleanType 
:
{ before(grammarAccess.getBooleanTypeRule()); }
	 ruleBooleanType
{ after(grammarAccess.getBooleanTypeRule()); } 
	 EOF 
;

// Rule BooleanType
ruleBooleanType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getBooleanTypeAccess().getGroup()); }
(rule__BooleanType__Group__0)
{ after(grammarAccess.getBooleanTypeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleStringType
entryRuleStringType 
:
{ before(grammarAccess.getStringTypeRule()); }
	 ruleStringType
{ after(grammarAccess.getStringTypeRule()); } 
	 EOF 
;

// Rule StringType
ruleStringType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getStringTypeAccess().getGroup()); }
(rule__StringType__Group__0)
{ after(grammarAccess.getStringTypeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



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

// Rule ArrayType
ruleArrayType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getArrayTypeAccess().getAlternatives()); }
(rule__ArrayType__Alternatives)
{ after(grammarAccess.getArrayTypeAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleTensorType
entryRuleTensorType 
:
{ before(grammarAccess.getTensorTypeRule()); }
	 ruleTensorType
{ after(grammarAccess.getTensorTypeRule()); } 
	 EOF 
;

// Rule TensorType
ruleTensorType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getTensorTypeAccess().getGroup()); }
(rule__TensorType__Group__0)
{ after(grammarAccess.getTensorTypeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleArrayDimension
entryRuleArrayDimension 
:
{ before(grammarAccess.getArrayDimensionRule()); }
	 ruleArrayDimension
{ after(grammarAccess.getArrayDimensionRule()); } 
	 EOF 
;

// Rule ArrayDimension
ruleArrayDimension
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getArrayDimensionAccess().getGroup()); }
(rule__ArrayDimension__Group__0)
{ after(grammarAccess.getArrayDimensionAccess().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 entryRuleLetExpression
entryRuleLetExpression 
:
{ before(grammarAccess.getLetExpressionRule()); }
	 ruleLetExpression
{ after(grammarAccess.getLetExpressionRule()); } 
	 EOF 
;

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

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleLetExpressionVariableDeclaration
entryRuleLetExpressionVariableDeclaration 
:
{ before(grammarAccess.getLetExpressionVariableDeclarationRule()); }
	 ruleLetExpressionVariableDeclaration
{ after(grammarAccess.getLetExpressionVariableDeclarationRule()); } 
	 EOF 
;

// Rule LetExpressionVariableDeclaration
ruleLetExpressionVariableDeclaration
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getGroup()); }
(rule__LetExpressionVariableDeclaration__Group__0)
{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleLetExpressionVariableDeclarationPart
entryRuleLetExpressionVariableDeclarationPart 
:
{ before(grammarAccess.getLetExpressionVariableDeclarationPartRule()); }
	 ruleLetExpressionVariableDeclarationPart
{ after(grammarAccess.getLetExpressionVariableDeclarationPartRule()); } 
	 EOF 
;

// Rule LetExpressionVariableDeclarationPart
ruleLetExpressionVariableDeclarationPart
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationPartAccess().getNameAssignment()); }
(rule__LetExpressionVariableDeclarationPart__NameAssignment)
{ after(grammarAccess.getLetExpressionVariableDeclarationPartAccess().getNameAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleIfExpression
entryRuleIfExpression 
:
{ before(grammarAccess.getIfExpressionRule()); }
	 ruleIfExpression
{ after(grammarAccess.getIfExpressionRule()); } 
	 EOF 
;

// Rule IfExpression
ruleIfExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getIfExpressionAccess().getGroup()); }
(rule__IfExpression__Group__0)
{ after(grammarAccess.getIfExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleSwitchExpression
entryRuleSwitchExpression 
:
{ before(grammarAccess.getSwitchExpressionRule()); }
	 ruleSwitchExpression
{ after(grammarAccess.getSwitchExpressionRule()); } 
	 EOF 
;

// Rule SwitchExpression
ruleSwitchExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSwitchExpressionAccess().getGroup()); }
(rule__SwitchExpression__Group__0)
{ after(grammarAccess.getSwitchExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleSwitchCase
entryRuleSwitchCase 
:
{ before(grammarAccess.getSwitchCaseRule()); }
	 ruleSwitchCase
{ after(grammarAccess.getSwitchCaseRule()); } 
	 EOF 
;

// Rule SwitchCase
ruleSwitchCase
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSwitchCaseAccess().getGroup()); }
(rule__SwitchCase__Group__0)
{ after(grammarAccess.getSwitchCaseAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleRangeExpression
entryRuleRangeExpression 
:
{ before(grammarAccess.getRangeExpressionRule()); }
	 ruleRangeExpression
{ after(grammarAccess.getRangeExpressionRule()); } 
	 EOF 
;

// Rule RangeExpression
ruleRangeExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRangeExpressionAccess().getGroup()); }
(rule__RangeExpression__Group__0)
{ after(grammarAccess.getRangeExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleImpliesExpression
entryRuleImpliesExpression 
:
{ before(grammarAccess.getImpliesExpressionRule()); }
	 ruleImpliesExpression
{ after(grammarAccess.getImpliesExpressionRule()); } 
	 EOF 
;

// Rule ImpliesExpression
ruleImpliesExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getImpliesExpressionAccess().getGroup()); }
(rule__ImpliesExpression__Group__0)
{ after(grammarAccess.getImpliesExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleLogicalOrExpression
entryRuleLogicalOrExpression 
:
{ before(grammarAccess.getLogicalOrExpressionRule()); }
	 ruleLogicalOrExpression
{ after(grammarAccess.getLogicalOrExpressionRule()); } 
	 EOF 
;

// Rule LogicalOrExpression
ruleLogicalOrExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getLogicalOrExpressionAccess().getGroup()); }
(rule__LogicalOrExpression__Group__0)
{ after(grammarAccess.getLogicalOrExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleLogicalAndExpression
entryRuleLogicalAndExpression 
:
{ before(grammarAccess.getLogicalAndExpressionRule()); }
	 ruleLogicalAndExpression
{ after(grammarAccess.getLogicalAndExpressionRule()); } 
	 EOF 
;

// Rule LogicalAndExpression
ruleLogicalAndExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getLogicalAndExpressionAccess().getGroup()); }
(rule__LogicalAndExpression__Group__0)
{ after(grammarAccess.getLogicalAndExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleEqualityExpression
entryRuleEqualityExpression 
:
{ before(grammarAccess.getEqualityExpressionRule()); }
	 ruleEqualityExpression
{ after(grammarAccess.getEqualityExpressionRule()); } 
	 EOF 
;

// Rule EqualityExpression
ruleEqualityExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getEqualityExpressionAccess().getGroup()); }
(rule__EqualityExpression__Group__0)
{ after(grammarAccess.getEqualityExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleRelationalExpression
entryRuleRelationalExpression 
:
{ before(grammarAccess.getRelationalExpressionRule()); }
	 ruleRelationalExpression
{ after(grammarAccess.getRelationalExpressionRule()); } 
	 EOF 
;

// Rule RelationalExpression
ruleRelationalExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRelationalExpressionAccess().getGroup()); }
(rule__RelationalExpression__Group__0)
{ after(grammarAccess.getRelationalExpressionAccess().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 entryRulePowerExpression
entryRulePowerExpression 
:
{ before(grammarAccess.getPowerExpressionRule()); }
	 rulePowerExpression
{ after(grammarAccess.getPowerExpressionRule()); } 
	 EOF 
;

// Rule PowerExpression
rulePowerExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getPowerExpressionAccess().getGroup()); }
(rule__PowerExpression__Group__0)
{ after(grammarAccess.getPowerExpressionAccess().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 entryRulePostfixExpression
entryRulePostfixExpression 
:
{ before(grammarAccess.getPostfixExpressionRule()); }
	 rulePostfixExpression
{ after(grammarAccess.getPostfixExpressionRule()); } 
	 EOF 
;

// Rule PostfixExpression
rulePostfixExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getPostfixExpressionAccess().getGroup()); }
(rule__PostfixExpression__Group__0)
{ after(grammarAccess.getPostfixExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleArrayElementAccess
entryRuleArrayElementAccess 
:
{ before(grammarAccess.getArrayElementAccessRule()); }
	 ruleArrayElementAccess
{ after(grammarAccess.getArrayElementAccessRule()); } 
	 EOF 
;

// Rule ArrayElementAccess
ruleArrayElementAccess
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getArrayElementAccessAccess().getGroup()); }
(rule__ArrayElementAccess__Group__0)
{ after(grammarAccess.getArrayElementAccessAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleMemberFeatureCall
entryRuleMemberFeatureCall 
:
{ before(grammarAccess.getMemberFeatureCallRule()); }
	 ruleMemberFeatureCall
{ after(grammarAccess.getMemberFeatureCallRule()); } 
	 EOF 
;

// Rule MemberFeatureCall
ruleMemberFeatureCall
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getGroup()); }
(rule__MemberFeatureCall__Group__0)
{ after(grammarAccess.getMemberFeatureCallAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleAssignableMemberFeatureCall
entryRuleAssignableMemberFeatureCall 
:
{ before(grammarAccess.getAssignableMemberFeatureCallRule()); }
	 ruleAssignableMemberFeatureCall
{ after(grammarAccess.getAssignableMemberFeatureCallRule()); } 
	 EOF 
;

// Rule AssignableMemberFeatureCall
ruleAssignableMemberFeatureCall
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getAssignableMemberFeatureCallAccess().getGroup()); }
(rule__AssignableMemberFeatureCall__Group__0)
{ after(grammarAccess.getAssignableMemberFeatureCallAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleIterationVariable
entryRuleIterationVariable 
:
{ before(grammarAccess.getIterationVariableRule()); }
	 ruleIterationVariable
{ after(grammarAccess.getIterationVariableRule()); } 
	 EOF 
;

// Rule IterationVariable
ruleIterationVariable
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getIterationVariableAccess().getNameAssignment()); }
(rule__IterationVariable__NameAssignment)
{ after(grammarAccess.getIterationVariableAccess().getNameAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleIterationAccumulator
entryRuleIterationAccumulator 
:
{ before(grammarAccess.getIterationAccumulatorRule()); }
	 ruleIterationAccumulator
{ after(grammarAccess.getIterationAccumulatorRule()); } 
	 EOF 
;

// Rule IterationAccumulator
ruleIterationAccumulator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getIterationAccumulatorAccess().getGroup()); }
(rule__IterationAccumulator__Group__0)
{ after(grammarAccess.getIterationAccumulatorAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleArraySubscript
entryRuleArraySubscript 
:
{ before(grammarAccess.getArraySubscriptRule()); }
	 ruleArraySubscript
{ after(grammarAccess.getArraySubscriptRule()); } 
	 EOF 
;

// Rule ArraySubscript
ruleArraySubscript
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getArraySubscriptAccess().getAlternatives()); }
(rule__ArraySubscript__Alternatives)
{ after(grammarAccess.getArraySubscriptAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRulePrimaryExpression
entryRulePrimaryExpression 
:
{ before(grammarAccess.getPrimaryExpressionRule()); }
	 rulePrimaryExpression
{ after(grammarAccess.getPrimaryExpressionRule()); } 
	 EOF 
;

// Rule PrimaryExpression
rulePrimaryExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getPrimaryExpressionAccess().getAlternatives()); }
(rule__PrimaryExpression__Alternatives)
{ after(grammarAccess.getPrimaryExpressionAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleAssignablePrimaryExpression
entryRuleAssignablePrimaryExpression 
:
{ before(grammarAccess.getAssignablePrimaryExpressionRule()); }
	 ruleAssignablePrimaryExpression
{ after(grammarAccess.getAssignablePrimaryExpressionRule()); } 
	 EOF 
;

// Rule AssignablePrimaryExpression
ruleAssignablePrimaryExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getAssignablePrimaryExpressionAccess().getAlternatives()); }
(rule__AssignablePrimaryExpression__Alternatives)
{ after(grammarAccess.getAssignablePrimaryExpressionAccess().getAlternatives()); }
)

;
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 entryRuleNumericLiteral
entryRuleNumericLiteral 
:
{ before(grammarAccess.getNumericLiteralRule()); }
	 ruleNumericLiteral
{ after(grammarAccess.getNumericLiteralRule()); } 
	 EOF 
;

// Rule NumericLiteral
ruleNumericLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getNumericLiteralAccess().getAlternatives()); }
(rule__NumericLiteral__Alternatives)
{ after(grammarAccess.getNumericLiteralAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



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

// Rule RealLiteral
ruleRealLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRealLiteralAccess().getGroup()); }
(rule__RealLiteral__Group__0)
{ after(grammarAccess.getRealLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleIntegerLiteral
entryRuleIntegerLiteral 
:
{ before(grammarAccess.getIntegerLiteralRule()); }
	 ruleIntegerLiteral
{ after(grammarAccess.getIntegerLiteralRule()); } 
	 EOF 
;

// Rule IntegerLiteral
ruleIntegerLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getIntegerLiteralAccess().getGroup()); }
(rule__IntegerLiteral__Group__0)
{ after(grammarAccess.getIntegerLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



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

// Rule BooleanLiteral
ruleBooleanLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getBooleanLiteralAccess().getGroup()); }
(rule__BooleanLiteral__Group__0)
{ after(grammarAccess.getBooleanLiteralAccess().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 entryRuleFeatureCall
entryRuleFeatureCall 
:
{ before(grammarAccess.getFeatureCallRule()); }
	 ruleFeatureCall
{ after(grammarAccess.getFeatureCallRule()); } 
	 EOF 
;

// Rule FeatureCall
ruleFeatureCall
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getFeatureCallAccess().getAlternatives()); }
(rule__FeatureCall__Alternatives)
{ after(grammarAccess.getFeatureCallAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleVariableAccess
entryRuleVariableAccess 
:
{ before(grammarAccess.getVariableAccessRule()); }
	 ruleVariableAccess
{ after(grammarAccess.getVariableAccessRule()); } 
	 EOF 
;

// Rule VariableAccess
ruleVariableAccess
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getVariableAccessAccess().getGroup()); }
(rule__VariableAccess__Group__0)
{ after(grammarAccess.getVariableAccessAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleFunctionCall
entryRuleFunctionCall 
:
{ before(grammarAccess.getFunctionCallRule()); }
	 ruleFunctionCall
{ after(grammarAccess.getFunctionCallRule()); } 
	 EOF 
;

// Rule FunctionCall
ruleFunctionCall
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getFunctionCallAccess().getGroup()); }
(rule__FunctionCall__Group__0)
{ after(grammarAccess.getFunctionCallAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleStepExpression
entryRuleStepExpression 
:
{ before(grammarAccess.getStepExpressionRule()); }
	 ruleStepExpression
{ after(grammarAccess.getStepExpressionRule()); } 
	 EOF 
;

// Rule StepExpression
ruleStepExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getStepExpressionAccess().getRangeStepExpressionParserRuleCall()); }
	ruleRangeStepExpression
{ after(grammarAccess.getStepExpressionAccess().getRangeStepExpressionParserRuleCall()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleRangeStepExpression
entryRuleRangeStepExpression 
:
{ before(grammarAccess.getRangeStepExpressionRule()); }
	 ruleRangeStepExpression
{ after(grammarAccess.getRangeStepExpressionRule()); } 
	 EOF 
;

// Rule RangeStepExpression
ruleRangeStepExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRangeStepExpressionAccess().getGroup()); }
(rule__RangeStepExpression__Group__0)
{ after(grammarAccess.getRangeStepExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleAdditiveStepExpression
entryRuleAdditiveStepExpression 
:
{ before(grammarAccess.getAdditiveStepExpressionRule()); }
	 ruleAdditiveStepExpression
{ after(grammarAccess.getAdditiveStepExpressionRule()); } 
	 EOF 
;

// Rule AdditiveStepExpression
ruleAdditiveStepExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getAdditiveStepExpressionAccess().getGroup()); }
(rule__AdditiveStepExpression__Group__0)
{ after(grammarAccess.getAdditiveStepExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleNegateStepExpression
entryRuleNegateStepExpression 
:
{ before(grammarAccess.getNegateStepExpressionRule()); }
	 ruleNegateStepExpression
{ after(grammarAccess.getNegateStepExpressionRule()); } 
	 EOF 
;

// Rule NegateStepExpression
ruleNegateStepExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getNegateStepExpressionAccess().getAlternatives()); }
(rule__NegateStepExpression__Alternatives)
{ after(grammarAccess.getNegateStepExpressionAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRulePrimitiveStepExpression
entryRulePrimitiveStepExpression 
:
{ before(grammarAccess.getPrimitiveStepExpressionRule()); }
	 rulePrimitiveStepExpression
{ after(grammarAccess.getPrimitiveStepExpressionRule()); } 
	 EOF 
;

// Rule PrimitiveStepExpression
rulePrimitiveStepExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getPrimitiveStepExpressionAccess().getAlternatives()); }
(rule__PrimitiveStepExpression__Alternatives)
{ after(grammarAccess.getPrimitiveStepExpressionAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleStepLiteral
entryRuleStepLiteral 
:
{ before(grammarAccess.getStepLiteralRule()); }
	 ruleStepLiteral
{ after(grammarAccess.getStepLiteralRule()); } 
	 EOF 
;

// Rule StepLiteral
ruleStepLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getStepLiteralAccess().getValueAssignment()); }
(rule__StepLiteral__ValueAssignment)
{ after(grammarAccess.getStepLiteralAccess().getValueAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleStepN
entryRuleStepN 
:
{ before(grammarAccess.getStepNRule()); }
	 ruleStepN
{ after(grammarAccess.getStepNRule()); } 
	 EOF 
;

// Rule StepN
ruleStepN
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getStepNAccess().getGroup()); }
(rule__StepN__Group__0)
{ after(grammarAccess.getStepNAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleDerivativeOperator
entryRuleDerivativeOperator 
:
{ before(grammarAccess.getDerivativeOperatorRule()); }
	 ruleDerivativeOperator
{ after(grammarAccess.getDerivativeOperatorRule()); } 
	 EOF 
;

// Rule DerivativeOperator
ruleDerivativeOperator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getDerivativeOperatorAccess().getGroup()); }
(rule__DerivativeOperator__Group__0)
{ after(grammarAccess.getDerivativeOperatorAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleArrayConstructionOperator
entryRuleArrayConstructionOperator 
:
{ before(grammarAccess.getArrayConstructionOperatorRule()); }
	 ruleArrayConstructionOperator
{ after(grammarAccess.getArrayConstructionOperatorRule()); } 
	 EOF 
;

// Rule ArrayConstructionOperator
ruleArrayConstructionOperator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getGroup()); }
(rule__ArrayConstructionOperator__Group__0)
{ after(grammarAccess.getArrayConstructionOperatorAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleArrayConstructionIterationClause
entryRuleArrayConstructionIterationClause 
:
{ before(grammarAccess.getArrayConstructionIterationClauseRule()); }
	 ruleArrayConstructionIterationClause
{ after(grammarAccess.getArrayConstructionIterationClauseRule()); } 
	 EOF 
;

// Rule ArrayConstructionIterationClause
ruleArrayConstructionIterationClause
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getArrayConstructionIterationClauseAccess().getGroup()); }
(rule__ArrayConstructionIterationClause__Group__0)
{ after(grammarAccess.getArrayConstructionIterationClauseAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleArrayConcatenationOperator
entryRuleArrayConcatenationOperator 
:
{ before(grammarAccess.getArrayConcatenationOperatorRule()); }
	 ruleArrayConcatenationOperator
{ after(grammarAccess.getArrayConcatenationOperatorRule()); } 
	 EOF 
;

// Rule ArrayConcatenationOperator
ruleArrayConcatenationOperator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getArrayConcatenationOperatorAccess().getGroup()); }
(rule__ArrayConcatenationOperator__Group__0)
{ after(grammarAccess.getArrayConcatenationOperatorAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleExpressionList
entryRuleExpressionList 
:
{ before(grammarAccess.getExpressionListRule()); }
	 ruleExpressionList
{ after(grammarAccess.getExpressionListRule()); } 
	 EOF 
;

// Rule ExpressionList
ruleExpressionList
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getExpressionListAccess().getGroup()); }
(rule__ExpressionList__Group__0)
{ after(grammarAccess.getExpressionListAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUnitConstructionOperator
entryRuleUnitConstructionOperator 
:
{ before(grammarAccess.getUnitConstructionOperatorRule()); }
	 ruleUnitConstructionOperator
{ after(grammarAccess.getUnitConstructionOperatorRule()); } 
	 EOF 
;

// Rule UnitConstructionOperator
ruleUnitConstructionOperator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUnitConstructionOperatorAccess().getGroup()); }
(rule__UnitConstructionOperator__Group__0)
{ after(grammarAccess.getUnitConstructionOperatorAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleParenthesizedExpression
entryRuleParenthesizedExpression 
:
{ before(grammarAccess.getParenthesizedExpressionRule()); }
	 ruleParenthesizedExpression
{ after(grammarAccess.getParenthesizedExpressionRule()); } 
	 EOF 
;

// Rule ParenthesizedExpression
ruleParenthesizedExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getParenthesizedExpressionAccess().getGroup()); }
(rule__ParenthesizedExpression__Group__0)
{ after(grammarAccess.getParenthesizedExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleEndExpression
entryRuleEndExpression 
:
{ before(grammarAccess.getEndExpressionRule()); }
	 ruleEndExpression
{ after(grammarAccess.getEndExpressionRule()); } 
	 EOF 
;

// Rule EndExpression
ruleEndExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getEndExpressionAccess().getGroup()); }
(rule__EndExpression__Group__0)
{ after(grammarAccess.getEndExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleAlgorithmExpression
entryRuleAlgorithmExpression 
:
{ before(grammarAccess.getAlgorithmExpressionRule()); }
	 ruleAlgorithmExpression
{ after(grammarAccess.getAlgorithmExpressionRule()); } 
	 EOF 
;

// Rule AlgorithmExpression
ruleAlgorithmExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getAlgorithmExpressionAccess().getGroup()); }
(rule__AlgorithmExpression__Group__0)
{ after(grammarAccess.getAlgorithmExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleCompound
entryRuleCompound 
:
{ before(grammarAccess.getCompoundRule()); }
	 ruleCompound
{ after(grammarAccess.getCompoundRule()); } 
	 EOF 
;

// Rule Compound
ruleCompound
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getCompoundAccess().getGroup()); }
(rule__Compound__Group__0)
{ after(grammarAccess.getCompoundAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



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

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

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleAssignment
entryRuleAssignment 
:
{ before(grammarAccess.getAssignmentRule()); }
	 ruleAssignment
{ after(grammarAccess.getAssignmentRule()); } 
	 EOF 
;

// Rule Assignment
ruleAssignment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getAssignmentAccess().getGroup()); }
(rule__Assignment__Group__0)
{ after(grammarAccess.getAssignmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



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

// Rule VariableDeclaration
ruleVariableDeclaration
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getVariableDeclarationAccess().getGroup()); }
(rule__VariableDeclaration__Group__0)
{ after(grammarAccess.getVariableDeclarationAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleIfStatement
entryRuleIfStatement 
:
{ before(grammarAccess.getIfStatementRule()); }
	 ruleIfStatement
{ after(grammarAccess.getIfStatementRule()); } 
	 EOF 
;

// Rule IfStatement
ruleIfStatement
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getIfStatementAccess().getGroup()); }
(rule__IfStatement__Group__0)
{ after(grammarAccess.getIfStatementAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



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

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

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleForStatement
entryRuleForStatement 
:
{ before(grammarAccess.getForStatementRule()); }
	 ruleForStatement
{ after(grammarAccess.getForStatementRule()); } 
	 EOF 
;

// Rule ForStatement
ruleForStatement
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getForStatementAccess().getGroup()); }
(rule__ForStatement__Group__0)
{ after(grammarAccess.getForStatementAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleDoWhileStatement
entryRuleDoWhileStatement 
:
{ before(grammarAccess.getDoWhileStatementRule()); }
	 ruleDoWhileStatement
{ after(grammarAccess.getDoWhileStatementRule()); } 
	 EOF 
;

// Rule DoWhileStatement
ruleDoWhileStatement
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getDoWhileStatementAccess().getGroup()); }
(rule__DoWhileStatement__Group__0)
{ after(grammarAccess.getDoWhileStatementAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleContinueStatement
entryRuleContinueStatement 
:
{ before(grammarAccess.getContinueStatementRule()); }
	 ruleContinueStatement
{ after(grammarAccess.getContinueStatementRule()); } 
	 EOF 
;

// Rule ContinueStatement
ruleContinueStatement
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getContinueStatementAccess().getGroup()); }
(rule__ContinueStatement__Group__0)
{ after(grammarAccess.getContinueStatementAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleBreakStatement
entryRuleBreakStatement 
:
{ before(grammarAccess.getBreakStatementRule()); }
	 ruleBreakStatement
{ after(grammarAccess.getBreakStatementRule()); } 
	 EOF 
;

// Rule BreakStatement
ruleBreakStatement
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getBreakStatementAccess().getGroup()); }
(rule__BreakStatement__Group__0)
{ after(grammarAccess.getBreakStatementAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



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

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

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUnit
entryRuleUnit 
:
{ before(grammarAccess.getUnitRule()); }
	 ruleUnit
{ after(grammarAccess.getUnitRule()); } 
	 EOF 
;

// Rule Unit
ruleUnit
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUnitAccess().getGroup()); }
(rule__Unit__Group__0)
{ after(grammarAccess.getUnitAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleExplicitUnit
entryRuleExplicitUnit 
:
{ before(grammarAccess.getExplicitUnitRule()); }
	 ruleExplicitUnit
{ after(grammarAccess.getExplicitUnitRule()); } 
	 EOF 
;

// Rule ExplicitUnit
ruleExplicitUnit
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getExplicitUnitAccess().getGroup()); }
(rule__ExplicitUnit__Group__0)
{ after(grammarAccess.getExplicitUnitAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUnitNumerator
entryRuleUnitNumerator 
:
{ before(grammarAccess.getUnitNumeratorRule()); }
	 ruleUnitNumerator
{ after(grammarAccess.getUnitNumeratorRule()); } 
	 EOF 
;

// Rule UnitNumerator
ruleUnitNumerator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUnitNumeratorAccess().getAlternatives()); }
(rule__UnitNumerator__Alternatives)
{ after(grammarAccess.getUnitNumeratorAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleImplicitUnitNumerator
entryRuleImplicitUnitNumerator 
:
{ before(grammarAccess.getImplicitUnitNumeratorRule()); }
	 ruleImplicitUnitNumerator
{ after(grammarAccess.getImplicitUnitNumeratorRule()); } 
	 EOF 
;

// Rule ImplicitUnitNumerator
ruleImplicitUnitNumerator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getImplicitUnitNumeratorAccess().getUnitNumeratorAction()); }
(

)
{ after(grammarAccess.getImplicitUnitNumeratorAccess().getUnitNumeratorAction()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUnitDenominator
entryRuleUnitDenominator 
:
{ before(grammarAccess.getUnitDenominatorRule()); }
	 ruleUnitDenominator
{ after(grammarAccess.getUnitDenominatorRule()); } 
	 EOF 
;

// Rule UnitDenominator
ruleUnitDenominator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUnitDenominatorAccess().getAlternatives()); }
(rule__UnitDenominator__Alternatives)
{ after(grammarAccess.getUnitDenominatorAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUnitFactor
entryRuleUnitFactor 
:
{ before(grammarAccess.getUnitFactorRule()); }
	 ruleUnitFactor
{ after(grammarAccess.getUnitFactorRule()); } 
	 EOF 
;

// Rule UnitFactor
ruleUnitFactor
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUnitFactorAccess().getGroup()); }
(rule__UnitFactor__Group__0)
{ after(grammarAccess.getUnitFactorAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUnitExponent
entryRuleUnitExponent 
:
{ before(grammarAccess.getUnitExponentRule()); }
	 ruleUnitExponent
{ after(grammarAccess.getUnitExponentRule()); } 
	 EOF 
;

// Rule UnitExponent
ruleUnitExponent
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUnitExponentAccess().getGroup()); }
(rule__UnitExponent__Group__0)
{ after(grammarAccess.getUnitExponentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleQualifiedName
entryRuleQualifiedName 
:
{ before(grammarAccess.getQualifiedNameRule()); }
	 ruleQualifiedName
{ after(grammarAccess.getQualifiedNameRule()); } 
	 EOF 
;

// Rule QualifiedName
ruleQualifiedName
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getQualifiedNameAccess().getGroup()); }
(rule__QualifiedName__Group__0)
{ after(grammarAccess.getQualifiedNameAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleValidDouble
entryRuleValidDouble 
:
{ before(grammarAccess.getValidDoubleRule()); }
	 ruleValidDouble
{ after(grammarAccess.getValidDoubleRule()); } 
	 EOF 
;

// Rule ValidDouble
ruleValidDouble
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getValidDoubleAccess().getREALTerminalRuleCall()); }
	RULE_REAL
{ after(grammarAccess.getValidDoubleAccess().getREALTerminalRuleCall()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleValidInt
entryRuleValidInt 
:
{ before(grammarAccess.getValidIntRule()); }
	 ruleValidInt
{ after(grammarAccess.getValidIntRule()); } 
	 EOF 
;

// Rule ValidInt
ruleValidInt
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getValidIntAccess().getAlternatives()); }
(rule__ValidInt__Alternatives)
{ after(grammarAccess.getValidIntAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleValidLong
entryRuleValidLong 
:
{ before(grammarAccess.getValidLongRule()); }
	 ruleValidLong
{ after(grammarAccess.getValidLongRule()); } 
	 EOF 
;

// Rule ValidLong
ruleValidLong
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getValidLongAccess().getAlternatives()); }
(rule__ValidLong__Alternatives)
{ after(grammarAccess.getValidLongAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleValidID
entryRuleValidID 
:
{ before(grammarAccess.getValidIDRule()); }
	 ruleValidID
{ after(grammarAccess.getValidIDRule()); } 
	 EOF 
;

// Rule ValidID
ruleValidID
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getValidIDAccess().getAlternatives()); }
(rule__ValidID__Alternatives)
{ after(grammarAccess.getValidIDAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}




// Rule FunctionKind
ruleFunctionKind
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionKindAccess().getAlternatives()); }
(rule__FunctionKind__Alternatives)
{ after(grammarAccess.getFunctionKindAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Rule AssertionStatusKind
ruleAssertionStatusKind
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssertionStatusKindAccess().getAlternatives()); }
(rule__AssertionStatusKind__Alternatives)
{ after(grammarAccess.getAssertionStatusKindAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Rule EqualityOperator
ruleEqualityOperator
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEqualityOperatorAccess().getAlternatives()); }
(rule__EqualityOperator__Alternatives)
{ after(grammarAccess.getEqualityOperatorAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Rule RelationalOperator
ruleRelationalOperator
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalOperatorAccess().getAlternatives()); }
(rule__RelationalOperator__Alternatives)
{ after(grammarAccess.getRelationalOperatorAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Rule AdditiveOperator
ruleAdditiveOperator
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAdditiveOperatorAccess().getAlternatives()); }
(rule__AdditiveOperator__Alternatives)
{ after(grammarAccess.getAdditiveOperatorAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Rule MultiplicativeOperator
ruleMultiplicativeOperator
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMultiplicativeOperatorAccess().getAlternatives()); }
(rule__MultiplicativeOperator__Alternatives)
{ after(grammarAccess.getMultiplicativeOperatorAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Rule PowerOperator
rulePowerOperator
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPowerOperatorAccess().getAlternatives()); }
(rule__PowerOperator__Alternatives)
{ after(grammarAccess.getPowerOperatorAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



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

;
finally {
	restoreStackSize(stackSize);
}



// Rule PostfixOperator
rulePostfixOperator
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPostfixOperatorAccess().getTransposeEnumLiteralDeclaration()); }
(	'\'' 
)
{ after(grammarAccess.getPostfixOperatorAccess().getTransposeEnumLiteralDeclaration()); }
)

;
finally {
	restoreStackSize(stackSize);
}



rule__Definition__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDefinitionAccess().getDataTypeDefinitionParserRuleCall_0()); }
	ruleDataTypeDefinition
{ after(grammarAccess.getDefinitionAccess().getDataTypeDefinitionParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getDefinitionAccess().getFunctionDefinitionParserRuleCall_1()); }
	ruleFunctionDefinition
{ after(grammarAccess.getDefinitionAccess().getFunctionDefinitionParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataTypeDefinition__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataTypeDefinitionAccess().getEnumerationDefinitionParserRuleCall_0()); }
	ruleEnumerationDefinition
{ after(grammarAccess.getDataTypeDefinitionAccess().getEnumerationDefinitionParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getDataTypeDefinitionAccess().getRecordDefinitionParserRuleCall_1()); }
	ruleRecordDefinition
{ after(grammarAccess.getDataTypeDefinitionAccess().getRecordDefinitionParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getDataTypeDefinitionAccess().getTypeAliasDefinitionParserRuleCall_2()); }
	ruleTypeAliasDefinition
{ after(grammarAccess.getDataTypeDefinitionAccess().getTypeAliasDefinitionParserRuleCall_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Alternatives_11
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getChecksAssignment_11_0()); }
(rule__FunctionDefinition__ChecksAssignment_11_0)
{ after(grammarAccess.getFunctionDefinitionAccess().getChecksAssignment_11_0()); }
)

    |(
{ before(grammarAccess.getFunctionDefinitionAccess().getAssertionsAssignment_11_1()); }
(rule__FunctionDefinition__AssertionsAssignment_11_1)
{ after(grammarAccess.getFunctionDefinitionAccess().getAssertionsAssignment_11_1()); }
)

    |(
{ before(grammarAccess.getFunctionDefinitionAccess().getFunctionObjectDeclarationsAssignment_11_2()); }
(rule__FunctionDefinition__FunctionObjectDeclarationsAssignment_11_2)
{ after(grammarAccess.getFunctionDefinitionAccess().getFunctionObjectDeclarationsAssignment_11_2()); }
)

    |(
{ before(grammarAccess.getFunctionDefinitionAccess().getStateVariableDeclarationsAssignment_11_3()); }
(rule__FunctionDefinition__StateVariableDeclarationsAssignment_11_3)
{ after(grammarAccess.getFunctionDefinitionAccess().getStateVariableDeclarationsAssignment_11_3()); }
)

    |(
{ before(grammarAccess.getFunctionDefinitionAccess().getEquationsAssignment_11_4()); }
(rule__FunctionDefinition__EquationsAssignment_11_4)
{ after(grammarAccess.getFunctionDefinitionAccess().getEquationsAssignment_11_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataTypeSpecifier__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataTypeSpecifierAccess().getDefinedTypeAssignment_0()); }
(rule__DataTypeSpecifier__DefinedTypeAssignment_0)
{ after(grammarAccess.getDataTypeSpecifierAccess().getDefinedTypeAssignment_0()); }
)

    |(
{ before(grammarAccess.getDataTypeSpecifierAccess().getTypeAssignment_1()); }
(rule__DataTypeSpecifier__TypeAssignment_1)
{ after(grammarAccess.getDataTypeSpecifierAccess().getTypeAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataTypeSpecifier__DefinedTypeAlternatives_0_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataTypeSpecifierAccess().getDefinedTypePrimitiveTypeParserRuleCall_0_0_0()); }
	rulePrimitiveType
{ after(grammarAccess.getDataTypeSpecifierAccess().getDefinedTypePrimitiveTypeParserRuleCall_0_0_0()); }
)

    |(
{ before(grammarAccess.getDataTypeSpecifierAccess().getDefinedTypeArrayTypeParserRuleCall_0_0_1()); }
	ruleArrayType
{ after(grammarAccess.getDataTypeSpecifierAccess().getDefinedTypeArrayTypeParserRuleCall_0_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getNumericTypeParserRuleCall_0()); }
	ruleNumericType
{ after(grammarAccess.getPrimitiveTypeAccess().getNumericTypeParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getPrimitiveTypeAccess().getBooleanTypeParserRuleCall_1()); }
	ruleBooleanType
{ after(grammarAccess.getPrimitiveTypeAccess().getBooleanTypeParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getPrimitiveTypeAccess().getStringTypeParserRuleCall_2()); }
	ruleStringType
{ after(grammarAccess.getPrimitiveTypeAccess().getStringTypeParserRuleCall_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__NumericType__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getNumericTypeAccess().getRealTypeParserRuleCall_0()); }
	ruleRealType
{ after(grammarAccess.getNumericTypeAccess().getRealTypeParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getNumericTypeAccess().getIntegerTypeParserRuleCall_1()); }
	ruleIntegerType
{ after(grammarAccess.getNumericTypeAccess().getIntegerTypeParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getNumericTypeAccess().getComplexTypeParserRuleCall_2()); }
	ruleComplexType
{ after(grammarAccess.getNumericTypeAccess().getComplexTypeParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getNumericTypeAccess().getGaussianTypeParserRuleCall_3()); }
	ruleGaussianType
{ after(grammarAccess.getNumericTypeAccess().getGaussianTypeParserRuleCall_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getTensorTypeParserRuleCall_0()); }
	ruleTensorType
{ after(grammarAccess.getArrayTypeAccess().getTensorTypeParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getArrayTypeAccess().getGroup_1()); }
(rule__ArrayType__Group_1__0)
{ after(grammarAccess.getArrayTypeAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Alternatives_1_0_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getDefinedElementTypeAssignment_1_0_0_0()); }
(rule__ArrayType__DefinedElementTypeAssignment_1_0_0_0)
{ after(grammarAccess.getArrayTypeAccess().getDefinedElementTypeAssignment_1_0_0_0()); }
)

    |(
{ before(grammarAccess.getArrayTypeAccess().getElementTypeAssignment_1_0_0_1()); }
(rule__ArrayType__ElementTypeAssignment_1_0_0_1)
{ after(grammarAccess.getArrayTypeAccess().getElementTypeAssignment_1_0_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Expression__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); }
	ruleLetExpression
{ after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getExpressionAccess().getIfExpressionParserRuleCall_1()); }
	ruleIfExpression
{ after(grammarAccess.getExpressionAccess().getIfExpressionParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getExpressionAccess().getSwitchExpressionParserRuleCall_2()); }
	ruleSwitchExpression
{ after(grammarAccess.getExpressionAccess().getSwitchExpressionParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getExpressionAccess().getRangeExpressionParserRuleCall_3()); }
	ruleRangeExpression
{ after(grammarAccess.getExpressionAccess().getRangeExpressionParserRuleCall_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__Alternatives_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getPartsAssignment_0_0()); }
(rule__LetExpressionVariableDeclaration__PartsAssignment_0_0)
{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getPartsAssignment_0_0()); }
)

    |(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getGroup_0_1()); }
(rule__LetExpressionVariableDeclaration__Group_0_1__0)
{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getGroup_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalExpression__Alternatives_1_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalExpressionAccess().getGroup_1_0_0()); }
(rule__RelationalExpression__Group_1_0_0__0)
{ after(grammarAccess.getRelationalExpressionAccess().getGroup_1_0_0()); }
)

    |(
{ before(grammarAccess.getRelationalExpressionAccess().getGroup_1_0_1()); }
(rule__RelationalExpression__Group_1_0_1__0)
{ after(grammarAccess.getRelationalExpressionAccess().getGroup_1_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnaryExpressionAccess().getPostfixExpressionParserRuleCall_0()); }
	rulePostfixExpression
{ after(grammarAccess.getUnaryExpressionAccess().getPostfixExpressionParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getUnaryExpressionAccess().getGroup_1()); }
(rule__UnaryExpression__Group_1__0)
{ after(grammarAccess.getUnaryExpressionAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Alternatives_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getGroup_1_0()); }
(rule__MemberFeatureCall__Group_1_0__0)
{ after(grammarAccess.getMemberFeatureCallAccess().getGroup_1_0()); }
)

    |(
{ before(grammarAccess.getMemberFeatureCallAccess().getGroup_1_1()); }
(rule__MemberFeatureCall__Group_1_1__0)
{ after(grammarAccess.getMemberFeatureCallAccess().getGroup_1_1()); }
)

    |(
{ before(grammarAccess.getMemberFeatureCallAccess().getGroup_1_2()); }
(rule__MemberFeatureCall__Group_1_2__0)
{ after(grammarAccess.getMemberFeatureCallAccess().getGroup_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArraySubscript__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArraySubscriptAccess().getSliceAssignment_0()); }
(rule__ArraySubscript__SliceAssignment_0)
{ after(grammarAccess.getArraySubscriptAccess().getSliceAssignment_0()); }
)

    |(
{ before(grammarAccess.getArraySubscriptAccess().getExpressionAssignment_1()); }
(rule__ArraySubscript__ExpressionAssignment_1)
{ after(grammarAccess.getArraySubscriptAccess().getExpressionAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PrimaryExpression__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); }
	ruleLiteral
{ after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); }
	ruleFeatureCall
{ after(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getPrimaryExpressionAccess().getDerivativeOperatorParserRuleCall_2()); }
	ruleDerivativeOperator
{ after(grammarAccess.getPrimaryExpressionAccess().getDerivativeOperatorParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getPrimaryExpressionAccess().getUnitConstructionOperatorParserRuleCall_3()); }
	ruleUnitConstructionOperator
{ after(grammarAccess.getPrimaryExpressionAccess().getUnitConstructionOperatorParserRuleCall_3()); }
)

    |(
{ before(grammarAccess.getPrimaryExpressionAccess().getArrayConstructionOperatorParserRuleCall_4()); }
	ruleArrayConstructionOperator
{ after(grammarAccess.getPrimaryExpressionAccess().getArrayConstructionOperatorParserRuleCall_4()); }
)

    |(
{ before(grammarAccess.getPrimaryExpressionAccess().getArrayConcatenationOperatorParserRuleCall_5()); }
	ruleArrayConcatenationOperator
{ after(grammarAccess.getPrimaryExpressionAccess().getArrayConcatenationOperatorParserRuleCall_5()); }
)

    |(
{ before(grammarAccess.getPrimaryExpressionAccess().getParenthesizedExpressionParserRuleCall_6()); }
	ruleParenthesizedExpression
{ after(grammarAccess.getPrimaryExpressionAccess().getParenthesizedExpressionParserRuleCall_6()); }
)

    |(
{ before(grammarAccess.getPrimaryExpressionAccess().getEndExpressionParserRuleCall_7()); }
	ruleEndExpression
{ after(grammarAccess.getPrimaryExpressionAccess().getEndExpressionParserRuleCall_7()); }
)

    |(
{ before(grammarAccess.getPrimaryExpressionAccess().getAlgorithmExpressionParserRuleCall_8()); }
	ruleAlgorithmExpression
{ after(grammarAccess.getPrimaryExpressionAccess().getAlgorithmExpressionParserRuleCall_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AssignablePrimaryExpression__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssignablePrimaryExpressionAccess().getFeatureCallParserRuleCall_0()); }
	ruleFeatureCall
{ after(grammarAccess.getAssignablePrimaryExpressionAccess().getFeatureCallParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getAssignablePrimaryExpressionAccess().getParenthesizedExpressionParserRuleCall_1()); }
	ruleParenthesizedExpression
{ after(grammarAccess.getAssignablePrimaryExpressionAccess().getParenthesizedExpressionParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Literal__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_0()); }
	ruleNumericLiteral
{ after(grammarAccess.getLiteralAccess().getNumericLiteralParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_1()); }
	ruleBooleanLiteral
{ after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_2()); }
	ruleStringLiteral
{ after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__NumericLiteral__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getNumericLiteralAccess().getRealLiteralParserRuleCall_0()); }
	ruleRealLiteral
{ after(grammarAccess.getNumericLiteralAccess().getRealLiteralParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getNumericLiteralAccess().getIntegerLiteralParserRuleCall_1()); }
	ruleIntegerLiteral
{ after(grammarAccess.getNumericLiteralAccess().getIntegerLiteralParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__Alternatives_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBooleanLiteralAccess().getTrueAssignment_1_0()); }
(rule__BooleanLiteral__TrueAssignment_1_0)
{ after(grammarAccess.getBooleanLiteralAccess().getTrueAssignment_1_0()); }
)

    |(
{ before(grammarAccess.getBooleanLiteralAccess().getFalseKeyword_1_1()); }

	'false' 

{ after(grammarAccess.getBooleanLiteralAccess().getFalseKeyword_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FeatureCall__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFeatureCallAccess().getVariableAccessParserRuleCall_0()); }
	ruleVariableAccess
{ after(grammarAccess.getFeatureCallAccess().getVariableAccessParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getFeatureCallAccess().getFunctionCallParserRuleCall_1()); }
	ruleFunctionCall
{ after(grammarAccess.getFeatureCallAccess().getFunctionCallParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__NegateStepExpression__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getNegateStepExpressionAccess().getPrimitiveStepExpressionParserRuleCall_0()); }
	rulePrimitiveStepExpression
{ after(grammarAccess.getNegateStepExpressionAccess().getPrimitiveStepExpressionParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getNegateStepExpressionAccess().getGroup_1()); }
(rule__NegateStepExpression__Group_1__0)
{ after(grammarAccess.getNegateStepExpressionAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveStepExpression__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveStepExpressionAccess().getStepLiteralParserRuleCall_0()); }
	ruleStepLiteral
{ after(grammarAccess.getPrimitiveStepExpressionAccess().getStepLiteralParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getPrimitiveStepExpressionAccess().getStepNParserRuleCall_1()); }
	ruleStepN
{ after(grammarAccess.getPrimitiveStepExpressionAccess().getStepNParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__Alternatives_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getGroup_2_0()); }
(rule__ArrayConstructionOperator__Group_2_0__0)*
{ after(grammarAccess.getArrayConstructionOperatorAccess().getGroup_2_0()); }
)

    |(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getGroup_2_1()); }
(rule__ArrayConstructionOperator__Group_2_1__0)
{ after(grammarAccess.getArrayConstructionOperatorAccess().getGroup_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Statement__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStatementAccess().getCompoundParserRuleCall_0()); }
	ruleCompound
{ after(grammarAccess.getStatementAccess().getCompoundParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getStatementAccess().getAssignmentParserRuleCall_1()); }
	ruleAssignment
{ after(grammarAccess.getStatementAccess().getAssignmentParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getStatementAccess().getVariableDeclarationParserRuleCall_2()); }
	ruleVariableDeclaration
{ after(grammarAccess.getStatementAccess().getVariableDeclarationParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getStatementAccess().getIfStatementParserRuleCall_3()); }
	ruleIfStatement
{ after(grammarAccess.getStatementAccess().getIfStatementParserRuleCall_3()); }
)

    |(
{ before(grammarAccess.getStatementAccess().getWhileStatementParserRuleCall_4()); }
	ruleWhileStatement
{ after(grammarAccess.getStatementAccess().getWhileStatementParserRuleCall_4()); }
)

    |(
{ before(grammarAccess.getStatementAccess().getDoWhileStatementParserRuleCall_5()); }
	ruleDoWhileStatement
{ after(grammarAccess.getStatementAccess().getDoWhileStatementParserRuleCall_5()); }
)

    |(
{ before(grammarAccess.getStatementAccess().getForStatementParserRuleCall_6()); }
	ruleForStatement
{ after(grammarAccess.getStatementAccess().getForStatementParserRuleCall_6()); }
)

    |(
{ before(grammarAccess.getStatementAccess().getContinueStatementParserRuleCall_7()); }
	ruleContinueStatement
{ after(grammarAccess.getStatementAccess().getContinueStatementParserRuleCall_7()); }
)

    |(
{ before(grammarAccess.getStatementAccess().getBreakStatementParserRuleCall_8()); }
	ruleBreakStatement
{ after(grammarAccess.getStatementAccess().getBreakStatementParserRuleCall_8()); }
)

    |(
{ before(grammarAccess.getStatementAccess().getReturnStatementParserRuleCall_9()); }
	ruleReturnStatement
{ after(grammarAccess.getStatementAccess().getReturnStatementParserRuleCall_9()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__Alternatives_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getGroup_1_0()); }
(rule__Unit__Group_1_0__0)
{ after(grammarAccess.getUnitAccess().getGroup_1_0()); }
)

    |(
{ before(grammarAccess.getUnitAccess().getGroup_1_1()); }
(rule__Unit__Group_1_1__0)
{ after(grammarAccess.getUnitAccess().getGroup_1_1()); }
)

    |(
{ before(grammarAccess.getUnitAccess().getNumeratorAssignment_1_2()); }
(rule__Unit__NumeratorAssignment_1_2)
{ after(grammarAccess.getUnitAccess().getNumeratorAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnitNumerator__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitNumeratorAccess().getGroup_0()); }
(rule__UnitNumerator__Group_0__0)
{ after(grammarAccess.getUnitNumeratorAccess().getGroup_0()); }
)

    |(
{ before(grammarAccess.getUnitNumeratorAccess().getGroup_1()); }
(rule__UnitNumerator__Group_1__0)
{ after(grammarAccess.getUnitNumeratorAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnitDenominator__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitDenominatorAccess().getFactorsAssignment_0()); }
(rule__UnitDenominator__FactorsAssignment_0)
{ after(grammarAccess.getUnitDenominatorAccess().getFactorsAssignment_0()); }
)

    |(
{ before(grammarAccess.getUnitDenominatorAccess().getGroup_1()); }
(rule__UnitDenominator__Group_1__0)
{ after(grammarAccess.getUnitDenominatorAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ValidInt__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getValidIntAccess().getONETerminalRuleCall_0()); }
	RULE_ONE
{ after(grammarAccess.getValidIntAccess().getONETerminalRuleCall_0()); }
)

    |(
{ before(grammarAccess.getValidIntAccess().getINTTerminalRuleCall_1()); }
	RULE_INT
{ after(grammarAccess.getValidIntAccess().getINTTerminalRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ValidLong__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getValidLongAccess().getONETerminalRuleCall_0()); }
	RULE_ONE
{ after(grammarAccess.getValidLongAccess().getONETerminalRuleCall_0()); }
)

    |(
{ before(grammarAccess.getValidLongAccess().getINTTerminalRuleCall_1()); }
	RULE_INT
{ after(grammarAccess.getValidLongAccess().getINTTerminalRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ValidID__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getValidIDAccess().getNTerminalRuleCall_0()); }
	RULE_N
{ after(grammarAccess.getValidIDAccess().getNTerminalRuleCall_0()); }
)

    |(
{ before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall_1()); }
	RULE_ID
{ after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionKind__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionKindAccess().getStatefulEnumLiteralDeclaration_0()); }
(	'stateful' 
)
{ after(grammarAccess.getFunctionKindAccess().getStatefulEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getFunctionKindAccess().getContinuousEnumLiteralDeclaration_1()); }
(	'continuous' 
)
{ after(grammarAccess.getFunctionKindAccess().getContinuousEnumLiteralDeclaration_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionStatusKind__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssertionStatusKindAccess().getInfoEnumLiteralDeclaration_0()); }
(	'info' 
)
{ after(grammarAccess.getAssertionStatusKindAccess().getInfoEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getAssertionStatusKindAccess().getWarningEnumLiteralDeclaration_1()); }
(	'warning' 
)
{ after(grammarAccess.getAssertionStatusKindAccess().getWarningEnumLiteralDeclaration_1()); }
)

    |(
{ before(grammarAccess.getAssertionStatusKindAccess().getErrorEnumLiteralDeclaration_2()); }
(	'error' 
)
{ after(grammarAccess.getAssertionStatusKindAccess().getErrorEnumLiteralDeclaration_2()); }
)

    |(
{ before(grammarAccess.getAssertionStatusKindAccess().getFatalEnumLiteralDeclaration_3()); }
(	'fatal' 
)
{ after(grammarAccess.getAssertionStatusKindAccess().getFatalEnumLiteralDeclaration_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EqualityOperator__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEqualityOperatorAccess().getEqualToEnumLiteralDeclaration_0()); }
(	'==' 
)
{ after(grammarAccess.getEqualityOperatorAccess().getEqualToEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getEqualityOperatorAccess().getNotEqualToEnumLiteralDeclaration_1()); }
(	'!=' 
)
{ after(grammarAccess.getEqualityOperatorAccess().getNotEqualToEnumLiteralDeclaration_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalOperator__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalOperatorAccess().getLessThanEnumLiteralDeclaration_0()); }
(	'<' 
)
{ after(grammarAccess.getRelationalOperatorAccess().getLessThanEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getRelationalOperatorAccess().getLessThanOrEqualToEnumLiteralDeclaration_1()); }
(	'<=' 
)
{ after(grammarAccess.getRelationalOperatorAccess().getLessThanOrEqualToEnumLiteralDeclaration_1()); }
)

    |(
{ before(grammarAccess.getRelationalOperatorAccess().getGreaterThanEnumLiteralDeclaration_2()); }
(	'>' 
)
{ after(grammarAccess.getRelationalOperatorAccess().getGreaterThanEnumLiteralDeclaration_2()); }
)

    |(
{ before(grammarAccess.getRelationalOperatorAccess().getGreaterThanOrEqualToEnumLiteralDeclaration_3()); }
(	'>=' 
)
{ after(grammarAccess.getRelationalOperatorAccess().getGreaterThanOrEqualToEnumLiteralDeclaration_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveOperator__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAdditiveOperatorAccess().getAddEnumLiteralDeclaration_0()); }
(	'+' 
)
{ after(grammarAccess.getAdditiveOperatorAccess().getAddEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getAdditiveOperatorAccess().getSubtractEnumLiteralDeclaration_1()); }
(	'-' 
)
{ after(grammarAccess.getAdditiveOperatorAccess().getSubtractEnumLiteralDeclaration_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeOperator__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMultiplicativeOperatorAccess().getMultiplyEnumLiteralDeclaration_0()); }
(	'*' 
)
{ after(grammarAccess.getMultiplicativeOperatorAccess().getMultiplyEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getMultiplicativeOperatorAccess().getDivideEnumLiteralDeclaration_1()); }
(	'/' 
)
{ after(grammarAccess.getMultiplicativeOperatorAccess().getDivideEnumLiteralDeclaration_1()); }
)

    |(
{ before(grammarAccess.getMultiplicativeOperatorAccess().getElementWiseMultiplyEnumLiteralDeclaration_2()); }
(	'.*' 
)
{ after(grammarAccess.getMultiplicativeOperatorAccess().getElementWiseMultiplyEnumLiteralDeclaration_2()); }
)

    |(
{ before(grammarAccess.getMultiplicativeOperatorAccess().getElementWiseDivideEnumLiteralDeclaration_3()); }
(	'./' 
)
{ after(grammarAccess.getMultiplicativeOperatorAccess().getElementWiseDivideEnumLiteralDeclaration_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PowerOperator__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPowerOperatorAccess().getPowerEnumLiteralDeclaration_0()); }
(	'^' 
)
{ after(grammarAccess.getPowerOperatorAccess().getPowerEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getPowerOperatorAccess().getElementWisePowerEnumLiteralDeclaration_1()); }
(	'.^' 
)
{ after(grammarAccess.getPowerOperatorAccess().getElementWisePowerEnumLiteralDeclaration_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryOperator__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnaryOperatorAccess().getNegateEnumLiteralDeclaration_0()); }
(	'-' 
)
{ after(grammarAccess.getUnaryOperatorAccess().getNegateEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getUnaryOperatorAccess().getLogicalNotEnumLiteralDeclaration_1()); }
(	'!' 
)
{ after(grammarAccess.getUnaryOperatorAccess().getLogicalNotEnumLiteralDeclaration_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}



rule__EnumerationDefinition__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationDefinition__Group__0__Impl
	rule__EnumerationDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationDefinition__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationDefinitionAccess().getEnumKeyword_0()); }

	'enum' 

{ after(grammarAccess.getEnumerationDefinitionAccess().getEnumKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationDefinition__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationDefinition__Group__1__Impl
	rule__EnumerationDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationDefinition__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationDefinitionAccess().getNameAssignment_1()); }
(rule__EnumerationDefinition__NameAssignment_1)
{ after(grammarAccess.getEnumerationDefinitionAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationDefinition__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationDefinition__Group__2__Impl
	rule__EnumerationDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationDefinition__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationDefinitionAccess().getLeftCurlyBracketKeyword_2()); }

	'{' 

{ after(grammarAccess.getEnumerationDefinitionAccess().getLeftCurlyBracketKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationDefinition__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationDefinition__Group__3__Impl
	rule__EnumerationDefinition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationDefinition__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationDefinitionAccess().getGroup_3()); }
(rule__EnumerationDefinition__Group_3__0)?
{ after(grammarAccess.getEnumerationDefinitionAccess().getGroup_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationDefinition__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationDefinition__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationDefinition__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationDefinitionAccess().getRightCurlyBracketKeyword_4()); }

	'}' 

{ after(grammarAccess.getEnumerationDefinitionAccess().getRightCurlyBracketKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__EnumerationDefinition__Group_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationDefinition__Group_3__0__Impl
	rule__EnumerationDefinition__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationDefinition__Group_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationDefinitionAccess().getLiteralDeclarationsAssignment_3_0()); }
(rule__EnumerationDefinition__LiteralDeclarationsAssignment_3_0)
{ after(grammarAccess.getEnumerationDefinitionAccess().getLiteralDeclarationsAssignment_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationDefinition__Group_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationDefinition__Group_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationDefinition__Group_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationDefinitionAccess().getGroup_3_1()); }
(rule__EnumerationDefinition__Group_3_1__0)*
{ after(grammarAccess.getEnumerationDefinitionAccess().getGroup_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__EnumerationDefinition__Group_3_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationDefinition__Group_3_1__0__Impl
	rule__EnumerationDefinition__Group_3_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationDefinition__Group_3_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationDefinitionAccess().getCommaKeyword_3_1_0()); }

	',' 

{ after(grammarAccess.getEnumerationDefinitionAccess().getCommaKeyword_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationDefinition__Group_3_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationDefinition__Group_3_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationDefinition__Group_3_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationDefinitionAccess().getLiteralDeclarationsAssignment_3_1_1()); }
(rule__EnumerationDefinition__LiteralDeclarationsAssignment_3_1_1)
{ after(grammarAccess.getEnumerationDefinitionAccess().getLiteralDeclarationsAssignment_3_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__TypeAliasDefinition__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TypeAliasDefinition__Group__0__Impl
	rule__TypeAliasDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeAliasDefinition__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTypeAliasDefinitionAccess().getTypeKeyword_0()); }

	'type' 

{ after(grammarAccess.getTypeAliasDefinitionAccess().getTypeKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TypeAliasDefinition__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TypeAliasDefinition__Group__1__Impl
	rule__TypeAliasDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeAliasDefinition__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTypeAliasDefinitionAccess().getNameAssignment_1()); }
(rule__TypeAliasDefinition__NameAssignment_1)
{ after(grammarAccess.getTypeAliasDefinitionAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TypeAliasDefinition__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TypeAliasDefinition__Group__2__Impl
	rule__TypeAliasDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeAliasDefinition__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTypeAliasDefinitionAccess().getEqualsSignKeyword_2()); }

	'=' 

{ after(grammarAccess.getTypeAliasDefinitionAccess().getEqualsSignKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TypeAliasDefinition__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TypeAliasDefinition__Group__3__Impl
	rule__TypeAliasDefinition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeAliasDefinition__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTypeAliasDefinitionAccess().getTypeAssignment_3()); }
(rule__TypeAliasDefinition__TypeAssignment_3)
{ after(grammarAccess.getTypeAliasDefinitionAccess().getTypeAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TypeAliasDefinition__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TypeAliasDefinition__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeAliasDefinition__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTypeAliasDefinitionAccess().getSemicolonKeyword_4()); }

	';' 

{ after(grammarAccess.getTypeAliasDefinitionAccess().getSemicolonKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__RecordDefinition__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RecordDefinition__Group__0__Impl
	rule__RecordDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordDefinition__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRecordDefinitionAccess().getRecordKeyword_0()); }

	'record' 

{ after(grammarAccess.getRecordDefinitionAccess().getRecordKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RecordDefinition__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RecordDefinition__Group__1__Impl
	rule__RecordDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordDefinition__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRecordDefinitionAccess().getNameAssignment_1()); }
(rule__RecordDefinition__NameAssignment_1)
{ after(grammarAccess.getRecordDefinitionAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RecordDefinition__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RecordDefinition__Group__2__Impl
	rule__RecordDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordDefinition__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRecordDefinitionAccess().getLeftCurlyBracketKeyword_2()); }

	'{' 

{ after(grammarAccess.getRecordDefinitionAccess().getLeftCurlyBracketKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RecordDefinition__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RecordDefinition__Group__3__Impl
	rule__RecordDefinition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordDefinition__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRecordDefinitionAccess().getFieldDeclarationsAssignment_3()); }
(rule__RecordDefinition__FieldDeclarationsAssignment_3)*
{ after(grammarAccess.getRecordDefinitionAccess().getFieldDeclarationsAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RecordDefinition__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RecordDefinition__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordDefinition__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRecordDefinitionAccess().getRightCurlyBracketKeyword_4()); }

	'}' 

{ after(grammarAccess.getRecordDefinitionAccess().getRightCurlyBracketKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__RecordFieldDeclaration__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RecordFieldDeclaration__Group__0__Impl
	rule__RecordFieldDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFieldDeclaration__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRecordFieldDeclarationAccess().getNameAssignment_0()); }
(rule__RecordFieldDeclaration__NameAssignment_0)
{ after(grammarAccess.getRecordFieldDeclarationAccess().getNameAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RecordFieldDeclaration__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RecordFieldDeclaration__Group__1__Impl
	rule__RecordFieldDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFieldDeclaration__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRecordFieldDeclarationAccess().getColonKeyword_1()); }

	':' 

{ after(grammarAccess.getRecordFieldDeclarationAccess().getColonKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RecordFieldDeclaration__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RecordFieldDeclaration__Group__2__Impl
	rule__RecordFieldDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFieldDeclaration__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRecordFieldDeclarationAccess().getTypeAssignment_2()); }
(rule__RecordFieldDeclaration__TypeAssignment_2)
{ after(grammarAccess.getRecordFieldDeclarationAccess().getTypeAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RecordFieldDeclaration__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RecordFieldDeclaration__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFieldDeclaration__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRecordFieldDeclarationAccess().getSemicolonKeyword_3()); }

	';' 

{ after(grammarAccess.getRecordFieldDeclarationAccess().getSemicolonKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










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

rule__FunctionDefinition__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getKindAssignment_0()); }
(rule__FunctionDefinition__KindAssignment_0)?
{ after(grammarAccess.getFunctionDefinitionAccess().getKindAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


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

rule__FunctionDefinition__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getFuncKeyword_1()); }

	'func' 

{ after(grammarAccess.getFunctionDefinitionAccess().getFuncKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


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

rule__FunctionDefinition__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getNameAssignment_2()); }
(rule__FunctionDefinition__NameAssignment_2)
{ after(grammarAccess.getFunctionDefinitionAccess().getNameAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


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

rule__FunctionDefinition__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getGroup_3()); }
(rule__FunctionDefinition__Group_3__0)?
{ after(grammarAccess.getFunctionDefinitionAccess().getGroup_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


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

rule__FunctionDefinition__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getLeftParenthesisKeyword_4()); }

	'(' 

{ after(grammarAccess.getFunctionDefinitionAccess().getLeftParenthesisKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group__5__Impl
	rule__FunctionDefinition__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getGroup_5()); }
(rule__FunctionDefinition__Group_5__0)?
{ after(grammarAccess.getFunctionDefinitionAccess().getGroup_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group__6__Impl
	rule__FunctionDefinition__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getRightParenthesisKeyword_6()); }

	')' 

{ after(grammarAccess.getFunctionDefinitionAccess().getRightParenthesisKeyword_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group__7__Impl
	rule__FunctionDefinition__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getHyphenMinusGreaterThanSignKeyword_7()); }

	'->' 

{ after(grammarAccess.getFunctionDefinitionAccess().getHyphenMinusGreaterThanSignKeyword_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group__8__Impl
	rule__FunctionDefinition__Group__9
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getOutputParameterDeclarationsAssignment_8()); }
(rule__FunctionDefinition__OutputParameterDeclarationsAssignment_8)
{ after(grammarAccess.getFunctionDefinitionAccess().getOutputParameterDeclarationsAssignment_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group__9
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group__9__Impl
	rule__FunctionDefinition__Group__10
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__9__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getGroup_9()); }
(rule__FunctionDefinition__Group_9__0)*
{ after(grammarAccess.getFunctionDefinitionAccess().getGroup_9()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group__10
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group__10__Impl
	rule__FunctionDefinition__Group__11
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__10__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getLeftCurlyBracketKeyword_10()); }

	'{' 

{ after(grammarAccess.getFunctionDefinitionAccess().getLeftCurlyBracketKeyword_10()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group__11
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group__11__Impl
	rule__FunctionDefinition__Group__12
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__11__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getAlternatives_11()); }
(rule__FunctionDefinition__Alternatives_11)*
{ after(grammarAccess.getFunctionDefinitionAccess().getAlternatives_11()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group__12
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group__12__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__12__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getRightCurlyBracketKeyword_12()); }

	'}' 

{ after(grammarAccess.getFunctionDefinitionAccess().getRightCurlyBracketKeyword_12()); }
)

;
finally {
	restoreStackSize(stackSize);
}




























rule__FunctionDefinition__Group_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group_3__0__Impl
	rule__FunctionDefinition__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getLessThanSignKeyword_3_0()); }

	'<' 

{ after(grammarAccess.getFunctionDefinitionAccess().getLessThanSignKeyword_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group_3__1__Impl
	rule__FunctionDefinition__Group_3__2
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getTemplateParameterDeclarationsAssignment_3_1()); }
(rule__FunctionDefinition__TemplateParameterDeclarationsAssignment_3_1)
{ after(grammarAccess.getFunctionDefinitionAccess().getTemplateParameterDeclarationsAssignment_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group_3__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group_3__2__Impl
	rule__FunctionDefinition__Group_3__3
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group_3__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getGroup_3_2()); }
(rule__FunctionDefinition__Group_3_2__0)*
{ after(grammarAccess.getFunctionDefinitionAccess().getGroup_3_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group_3__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group_3__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group_3__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getGreaterThanSignKeyword_3_3()); }

	'>' 

{ after(grammarAccess.getFunctionDefinitionAccess().getGreaterThanSignKeyword_3_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__FunctionDefinition__Group_3_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group_3_2__0__Impl
	rule__FunctionDefinition__Group_3_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group_3_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getCommaKeyword_3_2_0()); }

	',' 

{ after(grammarAccess.getFunctionDefinitionAccess().getCommaKeyword_3_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group_3_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group_3_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group_3_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getTemplateParameterDeclarationsAssignment_3_2_1()); }
(rule__FunctionDefinition__TemplateParameterDeclarationsAssignment_3_2_1)
{ after(grammarAccess.getFunctionDefinitionAccess().getTemplateParameterDeclarationsAssignment_3_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__FunctionDefinition__Group_5__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group_5__0__Impl
	rule__FunctionDefinition__Group_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group_5__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getInputParameterDeclarationsAssignment_5_0()); }
(rule__FunctionDefinition__InputParameterDeclarationsAssignment_5_0)
{ after(grammarAccess.getFunctionDefinitionAccess().getInputParameterDeclarationsAssignment_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group_5__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group_5__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group_5__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getGroup_5_1()); }
(rule__FunctionDefinition__Group_5_1__0)*
{ after(grammarAccess.getFunctionDefinitionAccess().getGroup_5_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__FunctionDefinition__Group_5_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group_5_1__0__Impl
	rule__FunctionDefinition__Group_5_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group_5_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getCommaKeyword_5_1_0()); }

	',' 

{ after(grammarAccess.getFunctionDefinitionAccess().getCommaKeyword_5_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group_5_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group_5_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group_5_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getInputParameterDeclarationsAssignment_5_1_1()); }
(rule__FunctionDefinition__InputParameterDeclarationsAssignment_5_1_1)
{ after(grammarAccess.getFunctionDefinitionAccess().getInputParameterDeclarationsAssignment_5_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__FunctionDefinition__Group_9__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group_9__0__Impl
	rule__FunctionDefinition__Group_9__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group_9__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getCommaKeyword_9_0()); }

	',' 

{ after(grammarAccess.getFunctionDefinitionAccess().getCommaKeyword_9_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group_9__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionDefinition__Group_9__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group_9__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getOutputParameterDeclarationsAssignment_9_1()); }
(rule__FunctionDefinition__OutputParameterDeclarationsAssignment_9_1)
{ after(grammarAccess.getFunctionDefinitionAccess().getOutputParameterDeclarationsAssignment_9_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Check__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group__0__Impl
	rule__Check__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getCheckKeyword_0()); }

	'check' 

{ after(grammarAccess.getCheckAccess().getCheckKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group__1__Impl
	rule__Check__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getGroup_1()); }
(rule__Check__Group_1__0)?
{ after(grammarAccess.getCheckAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group__2__Impl
	rule__Check__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getLeftParenthesisKeyword_2()); }

	'(' 

{ after(grammarAccess.getCheckAccess().getLeftParenthesisKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group__3__Impl
	rule__Check__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getGroup_3()); }
(rule__Check__Group_3__0)?
{ after(grammarAccess.getCheckAccess().getGroup_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group__4__Impl
	rule__Check__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getRightParenthesisKeyword_4()); }

	')' 

{ after(grammarAccess.getCheckAccess().getRightParenthesisKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group__5__Impl
	rule__Check__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getHyphenMinusGreaterThanSignKeyword_5()); }

	'->' 

{ after(grammarAccess.getCheckAccess().getHyphenMinusGreaterThanSignKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group__6__Impl
	rule__Check__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getOutputParameterTypesAssignment_6()); }
(rule__Check__OutputParameterTypesAssignment_6)
{ after(grammarAccess.getCheckAccess().getOutputParameterTypesAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group__7__Impl
	rule__Check__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getGroup_7()); }
(rule__Check__Group_7__0)*
{ after(grammarAccess.getCheckAccess().getGroup_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group__8__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getSemicolonKeyword_8()); }

	';' 

{ after(grammarAccess.getCheckAccess().getSemicolonKeyword_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}




















rule__Check__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group_1__0__Impl
	rule__Check__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getLessThanSignKeyword_1_0()); }

	'<' 

{ after(grammarAccess.getCheckAccess().getLessThanSignKeyword_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group_1__1__Impl
	rule__Check__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getTemplateArgumentsAssignment_1_1()); }
(rule__Check__TemplateArgumentsAssignment_1_1)
{ after(grammarAccess.getCheckAccess().getTemplateArgumentsAssignment_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group_1__2__Impl
	rule__Check__Group_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getGroup_1_2()); }
(rule__Check__Group_1_2__0)*
{ after(grammarAccess.getCheckAccess().getGroup_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group_1__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group_1__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getGreaterThanSignKeyword_1_3()); }

	'>' 

{ after(grammarAccess.getCheckAccess().getGreaterThanSignKeyword_1_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__Check__Group_1_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group_1_2__0__Impl
	rule__Check__Group_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group_1_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getCommaKeyword_1_2_0()); }

	',' 

{ after(grammarAccess.getCheckAccess().getCommaKeyword_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group_1_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group_1_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group_1_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getTemplateArgumentsAssignment_1_2_1()); }
(rule__Check__TemplateArgumentsAssignment_1_2_1)
{ after(grammarAccess.getCheckAccess().getTemplateArgumentsAssignment_1_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Check__Group_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group_3__0__Impl
	rule__Check__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getInputParameterTypesAssignment_3_0()); }
(rule__Check__InputParameterTypesAssignment_3_0)
{ after(grammarAccess.getCheckAccess().getInputParameterTypesAssignment_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getGroup_3_1()); }
(rule__Check__Group_3_1__0)*
{ after(grammarAccess.getCheckAccess().getGroup_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Check__Group_3_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group_3_1__0__Impl
	rule__Check__Group_3_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group_3_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getCommaKeyword_3_1_0()); }

	',' 

{ after(grammarAccess.getCheckAccess().getCommaKeyword_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group_3_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group_3_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group_3_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getInputParameterTypesAssignment_3_1_1()); }
(rule__Check__InputParameterTypesAssignment_3_1_1)
{ after(grammarAccess.getCheckAccess().getInputParameterTypesAssignment_3_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Check__Group_7__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group_7__0__Impl
	rule__Check__Group_7__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group_7__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getCommaKeyword_7_0()); }

	',' 

{ after(grammarAccess.getCheckAccess().getCommaKeyword_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Check__Group_7__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Check__Group_7__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Check__Group_7__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getOutputParameterTypesAssignment_7_1()); }
(rule__Check__OutputParameterTypesAssignment_7_1)
{ after(grammarAccess.getCheckAccess().getOutputParameterTypesAssignment_7_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Assertion__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Assertion__Group__0__Impl
	rule__Assertion__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Assertion__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssertionAccess().getStaticAssignment_0()); }
(rule__Assertion__StaticAssignment_0)?
{ after(grammarAccess.getAssertionAccess().getStaticAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Assertion__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Assertion__Group__1__Impl
	rule__Assertion__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Assertion__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssertionAccess().getAssertKeyword_1()); }

	'assert' 

{ after(grammarAccess.getAssertionAccess().getAssertKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Assertion__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Assertion__Group__2__Impl
	rule__Assertion__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Assertion__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssertionAccess().getConditionAssignment_2()); }
(rule__Assertion__ConditionAssignment_2)
{ after(grammarAccess.getAssertionAccess().getConditionAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Assertion__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Assertion__Group__3__Impl
	rule__Assertion__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__Assertion__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssertionAccess().getColonKeyword_3()); }

	':' 

{ after(grammarAccess.getAssertionAccess().getColonKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Assertion__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Assertion__Group__4__Impl
	rule__Assertion__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__Assertion__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssertionAccess().getStatusKindAssignment_4()); }
(rule__Assertion__StatusKindAssignment_4)
{ after(grammarAccess.getAssertionAccess().getStatusKindAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Assertion__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Assertion__Group__5__Impl
	rule__Assertion__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__Assertion__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssertionAccess().getMessageAssignment_5()); }
(rule__Assertion__MessageAssignment_5)
{ after(grammarAccess.getAssertionAccess().getMessageAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Assertion__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Assertion__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Assertion__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssertionAccess().getSemicolonKeyword_6()); }

	';' 

{ after(grammarAccess.getAssertionAccess().getSemicolonKeyword_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__StateVariableDeclaration__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StateVariableDeclaration__Group__0__Impl
	rule__StateVariableDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StateVariableDeclaration__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateVariableDeclarationAccess().getVarKeyword_0()); }

	'var' 

{ after(grammarAccess.getStateVariableDeclarationAccess().getVarKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StateVariableDeclaration__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StateVariableDeclaration__Group__1__Impl
	rule__StateVariableDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__StateVariableDeclaration__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateVariableDeclarationAccess().getNameAssignment_1()); }
(rule__StateVariableDeclaration__NameAssignment_1)
{ after(grammarAccess.getStateVariableDeclarationAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StateVariableDeclaration__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StateVariableDeclaration__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StateVariableDeclaration__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateVariableDeclarationAccess().getSemicolonKeyword_2()); }

	';' 

{ after(grammarAccess.getStateVariableDeclarationAccess().getSemicolonKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__FunctionObjectDeclaration__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionObjectDeclaration__Group__0__Impl
	rule__FunctionObjectDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getFobKeyword_0()); }

	'fob' 

{ after(grammarAccess.getFunctionObjectDeclarationAccess().getFobKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionObjectDeclaration__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionObjectDeclaration__Group__1__Impl
	rule__FunctionObjectDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getNameAssignment_1()); }
(rule__FunctionObjectDeclaration__NameAssignment_1)
{ after(grammarAccess.getFunctionObjectDeclarationAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionObjectDeclaration__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionObjectDeclaration__Group__2__Impl
	rule__FunctionObjectDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getColonKeyword_2()); }

	':' 

{ after(grammarAccess.getFunctionObjectDeclarationAccess().getColonKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionObjectDeclaration__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionObjectDeclaration__Group__3__Impl
	rule__FunctionObjectDeclaration__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getFunctionNameAssignment_3()); }
(rule__FunctionObjectDeclaration__FunctionNameAssignment_3)
{ after(grammarAccess.getFunctionObjectDeclarationAccess().getFunctionNameAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionObjectDeclaration__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionObjectDeclaration__Group__4__Impl
	rule__FunctionObjectDeclaration__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getGroup_4()); }
(rule__FunctionObjectDeclaration__Group_4__0)?
{ after(grammarAccess.getFunctionObjectDeclarationAccess().getGroup_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionObjectDeclaration__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionObjectDeclaration__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getSemicolonKeyword_5()); }

	';' 

{ after(grammarAccess.getFunctionObjectDeclarationAccess().getSemicolonKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}














rule__FunctionObjectDeclaration__Group_4__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionObjectDeclaration__Group_4__0__Impl
	rule__FunctionObjectDeclaration__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__Group_4__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getLessThanSignKeyword_4_0()); }

	'<' 

{ after(grammarAccess.getFunctionObjectDeclarationAccess().getLessThanSignKeyword_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionObjectDeclaration__Group_4__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionObjectDeclaration__Group_4__1__Impl
	rule__FunctionObjectDeclaration__Group_4__2
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__Group_4__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getTemplateArgumentsAssignment_4_1()); }
(rule__FunctionObjectDeclaration__TemplateArgumentsAssignment_4_1)
{ after(grammarAccess.getFunctionObjectDeclarationAccess().getTemplateArgumentsAssignment_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionObjectDeclaration__Group_4__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionObjectDeclaration__Group_4__2__Impl
	rule__FunctionObjectDeclaration__Group_4__3
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__Group_4__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getGroup_4_2()); }
(rule__FunctionObjectDeclaration__Group_4_2__0)*
{ after(grammarAccess.getFunctionObjectDeclarationAccess().getGroup_4_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionObjectDeclaration__Group_4__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionObjectDeclaration__Group_4__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__Group_4__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getGreaterThanSignKeyword_4_3()); }

	'>' 

{ after(grammarAccess.getFunctionObjectDeclarationAccess().getGreaterThanSignKeyword_4_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__FunctionObjectDeclaration__Group_4_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionObjectDeclaration__Group_4_2__0__Impl
	rule__FunctionObjectDeclaration__Group_4_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__Group_4_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getCommaKeyword_4_2_0()); }

	',' 

{ after(grammarAccess.getFunctionObjectDeclarationAccess().getCommaKeyword_4_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionObjectDeclaration__Group_4_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionObjectDeclaration__Group_4_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__Group_4_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getTemplateArgumentsAssignment_4_2_1()); }
(rule__FunctionObjectDeclaration__TemplateArgumentsAssignment_4_2_1)
{ after(grammarAccess.getFunctionObjectDeclarationAccess().getTemplateArgumentsAssignment_4_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Equation__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Equation__Group__0__Impl
	rule__Equation__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Equation__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEquationAccess().getInitialAssignment_0()); }
(rule__Equation__InitialAssignment_0)?
{ after(grammarAccess.getEquationAccess().getInitialAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Equation__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Equation__Group__1__Impl
	rule__Equation__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Equation__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEquationAccess().getLeftHandSideAssignment_1()); }
(rule__Equation__LeftHandSideAssignment_1)
{ after(grammarAccess.getEquationAccess().getLeftHandSideAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Equation__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Equation__Group__2__Impl
	rule__Equation__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Equation__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEquationAccess().getEqualsSignKeyword_2()); }

	'=' 

{ after(grammarAccess.getEquationAccess().getEqualsSignKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Equation__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Equation__Group__3__Impl
	rule__Equation__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__Equation__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEquationAccess().getRightHandSideAssignment_3()); }
(rule__Equation__RightHandSideAssignment_3)
{ after(grammarAccess.getEquationAccess().getRightHandSideAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Equation__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Equation__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Equation__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEquationAccess().getSemicolonKeyword_4()); }

	';' 

{ after(grammarAccess.getEquationAccess().getSemicolonKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__RealType__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RealType__Group__0__Impl
	rule__RealType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RealType__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealTypeAccess().getRealTypeAction_0()); }
(

)
{ after(grammarAccess.getRealTypeAccess().getRealTypeAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RealType__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RealType__Group__1__Impl
	rule__RealType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RealType__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealTypeAccess().getRealKeyword_1()); }

	'real' 

{ after(grammarAccess.getRealTypeAccess().getRealKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RealType__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RealType__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RealType__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealTypeAccess().getUnitAssignment_2()); }
(rule__RealType__UnitAssignment_2)
{ after(grammarAccess.getRealTypeAccess().getUnitAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__IntegerType__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IntegerType__Group__0__Impl
	rule__IntegerType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerType__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntegerTypeAccess().getIntegerTypeAction_0()); }
(

)
{ after(grammarAccess.getIntegerTypeAccess().getIntegerTypeAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IntegerType__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IntegerType__Group__1__Impl
	rule__IntegerType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerType__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntegerTypeAccess().getIntKeyword_1()); }

	'int' 

{ after(grammarAccess.getIntegerTypeAccess().getIntKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IntegerType__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IntegerType__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerType__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntegerTypeAccess().getUnitAssignment_2()); }
(rule__IntegerType__UnitAssignment_2)
{ after(grammarAccess.getIntegerTypeAccess().getUnitAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__ComplexType__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ComplexType__Group__0__Impl
	rule__ComplexType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComplexType__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getComplexTypeAccess().getComplexTypeAction_0()); }
(

)
{ after(grammarAccess.getComplexTypeAccess().getComplexTypeAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ComplexType__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ComplexType__Group__1__Impl
	rule__ComplexType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ComplexType__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getComplexTypeAccess().getComplexKeyword_1()); }

	'complex' 

{ after(grammarAccess.getComplexTypeAccess().getComplexKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ComplexType__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ComplexType__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComplexType__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getComplexTypeAccess().getUnitAssignment_2()); }
(rule__ComplexType__UnitAssignment_2)
{ after(grammarAccess.getComplexTypeAccess().getUnitAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__GaussianType__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GaussianType__Group__0__Impl
	rule__GaussianType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__GaussianType__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGaussianTypeAccess().getGaussianTypeAction_0()); }
(

)
{ after(grammarAccess.getGaussianTypeAccess().getGaussianTypeAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__GaussianType__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GaussianType__Group__1__Impl
	rule__GaussianType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__GaussianType__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGaussianTypeAccess().getGaussKeyword_1()); }

	'gauss' 

{ after(grammarAccess.getGaussianTypeAccess().getGaussKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__GaussianType__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GaussianType__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__GaussianType__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGaussianTypeAccess().getUnitAssignment_2()); }
(rule__GaussianType__UnitAssignment_2)
{ after(grammarAccess.getGaussianTypeAccess().getUnitAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__BooleanType__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BooleanType__Group__0__Impl
	rule__BooleanType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanType__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBooleanTypeAccess().getBooleanTypeAction_0()); }
(

)
{ after(grammarAccess.getBooleanTypeAccess().getBooleanTypeAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__BooleanType__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BooleanType__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanType__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBooleanTypeAccess().getBoolKeyword_1()); }

	'bool' 

{ after(grammarAccess.getBooleanTypeAccess().getBoolKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__StringType__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StringType__Group__0__Impl
	rule__StringType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StringType__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStringTypeAccess().getStringTypeAction_0()); }
(

)
{ after(grammarAccess.getStringTypeAccess().getStringTypeAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StringType__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StringType__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StringType__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStringTypeAccess().getStringKeyword_1()); }

	'string' 

{ after(grammarAccess.getStringTypeAccess().getStringKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ArrayType__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayType__Group_1__0__Impl
	rule__ArrayType__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getGroup_1_0()); }
(rule__ArrayType__Group_1_0__0)
{ after(grammarAccess.getArrayTypeAccess().getGroup_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayType__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayType__Group_1__1__Impl
	rule__ArrayType__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getLeftSquareBracketKeyword_1_1()); }

	'[' 

{ after(grammarAccess.getArrayTypeAccess().getLeftSquareBracketKeyword_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayType__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayType__Group_1__2__Impl
	rule__ArrayType__Group_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getDimensionsAssignment_1_2()); }
(rule__ArrayType__DimensionsAssignment_1_2)
{ after(grammarAccess.getArrayTypeAccess().getDimensionsAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayType__Group_1__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayType__Group_1__3__Impl
	rule__ArrayType__Group_1__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group_1__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getGroup_1_3()); }
(rule__ArrayType__Group_1_3__0)*
{ after(grammarAccess.getArrayTypeAccess().getGroup_1_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayType__Group_1__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayType__Group_1__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group_1__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getRightSquareBracketKeyword_1_4()); }

	']' 

{ after(grammarAccess.getArrayTypeAccess().getRightSquareBracketKeyword_1_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__ArrayType__Group_1_0__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayType__Group_1_0__0__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group_1_0__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getAlternatives_1_0_0()); }
(rule__ArrayType__Alternatives_1_0_0)
{ after(grammarAccess.getArrayTypeAccess().getAlternatives_1_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}




rule__ArrayType__Group_1_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayType__Group_1_3__0__Impl
	rule__ArrayType__Group_1_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group_1_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getCommaKeyword_1_3_0()); }

	',' 

{ after(grammarAccess.getArrayTypeAccess().getCommaKeyword_1_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayType__Group_1_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayType__Group_1_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group_1_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getDimensionsAssignment_1_3_1()); }
(rule__ArrayType__DimensionsAssignment_1_3_1)
{ after(grammarAccess.getArrayTypeAccess().getDimensionsAssignment_1_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__TensorType__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TensorType__Group__0__Impl
	rule__TensorType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TensorType__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTensorTypeAccess().getDefinedElementTypeAssignment_0()); }
(rule__TensorType__DefinedElementTypeAssignment_0)
{ after(grammarAccess.getTensorTypeAccess().getDefinedElementTypeAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TensorType__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TensorType__Group__1__Impl
	rule__TensorType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__TensorType__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTensorTypeAccess().getLeftSquareBracketKeyword_1()); }

	'[' 

{ after(grammarAccess.getTensorTypeAccess().getLeftSquareBracketKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TensorType__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TensorType__Group__2__Impl
	rule__TensorType__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__TensorType__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTensorTypeAccess().getDimensionsAssignment_2()); }
(rule__TensorType__DimensionsAssignment_2)
{ after(grammarAccess.getTensorTypeAccess().getDimensionsAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TensorType__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TensorType__Group__3__Impl
	rule__TensorType__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__TensorType__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTensorTypeAccess().getGroup_3()); }
(rule__TensorType__Group_3__0)*
{ after(grammarAccess.getTensorTypeAccess().getGroup_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TensorType__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TensorType__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TensorType__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTensorTypeAccess().getRightSquareBracketKeyword_4()); }

	']' 

{ after(grammarAccess.getTensorTypeAccess().getRightSquareBracketKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__TensorType__Group_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TensorType__Group_3__0__Impl
	rule__TensorType__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TensorType__Group_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTensorTypeAccess().getCommaKeyword_3_0()); }

	',' 

{ after(grammarAccess.getTensorTypeAccess().getCommaKeyword_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TensorType__Group_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TensorType__Group_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TensorType__Group_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTensorTypeAccess().getDimensionsAssignment_3_1()); }
(rule__TensorType__DimensionsAssignment_3_1)
{ after(grammarAccess.getTensorTypeAccess().getDimensionsAssignment_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ArrayDimension__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayDimension__Group__0__Impl
	rule__ArrayDimension__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayDimension__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayDimensionAccess().getArrayDimensionAction_0()); }
(

)
{ after(grammarAccess.getArrayDimensionAccess().getArrayDimensionAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayDimension__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayDimension__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayDimension__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayDimensionAccess().getSizeAssignment_1()); }
(rule__ArrayDimension__SizeAssignment_1)?
{ after(grammarAccess.getArrayDimensionAccess().getSizeAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






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

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

	'let' 

{ after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


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

rule__LetExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionAccess().getVariableDeclarationsAssignment_1()); }
(rule__LetExpression__VariableDeclarationsAssignment_1)
{ after(grammarAccess.getLetExpressionAccess().getVariableDeclarationsAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


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

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

;
finally {
	restoreStackSize(stackSize);
}


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

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

	'in' 

{ after(grammarAccess.getLetExpressionAccess().getInKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


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

rule__LetExpression__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionAccess().getTargetExpressionAssignment_4()); }
(rule__LetExpression__TargetExpressionAssignment_4)
{ after(grammarAccess.getLetExpressionAccess().getTargetExpressionAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












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

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

	',' 

{ after(grammarAccess.getLetExpressionAccess().getCommaKeyword_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


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

rule__LetExpression__Group_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionAccess().getVariableDeclarationsAssignment_2_1()); }
(rule__LetExpression__VariableDeclarationsAssignment_2_1)
{ after(grammarAccess.getLetExpressionAccess().getVariableDeclarationsAssignment_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__LetExpressionVariableDeclaration__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LetExpressionVariableDeclaration__Group__0__Impl
	rule__LetExpressionVariableDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getAlternatives_0()); }
(rule__LetExpressionVariableDeclaration__Alternatives_0)
{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getAlternatives_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LetExpressionVariableDeclaration__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LetExpressionVariableDeclaration__Group__1__Impl
	rule__LetExpressionVariableDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getEqualsSignKeyword_1()); }

	'=' 

{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getEqualsSignKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LetExpressionVariableDeclaration__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LetExpressionVariableDeclaration__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getAssignedExpressionAssignment_2()); }
(rule__LetExpressionVariableDeclaration__AssignedExpressionAssignment_2)
{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getAssignedExpressionAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__LetExpressionVariableDeclaration__Group_0_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LetExpressionVariableDeclaration__Group_0_1__0__Impl
	rule__LetExpressionVariableDeclaration__Group_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__Group_0_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getLeftParenthesisKeyword_0_1_0()); }

	'(' 

{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getLeftParenthesisKeyword_0_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LetExpressionVariableDeclaration__Group_0_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LetExpressionVariableDeclaration__Group_0_1__1__Impl
	rule__LetExpressionVariableDeclaration__Group_0_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__Group_0_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getPartsAssignment_0_1_1()); }
(rule__LetExpressionVariableDeclaration__PartsAssignment_0_1_1)
{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getPartsAssignment_0_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LetExpressionVariableDeclaration__Group_0_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LetExpressionVariableDeclaration__Group_0_1__2__Impl
	rule__LetExpressionVariableDeclaration__Group_0_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__Group_0_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getGroup_0_1_2()); }
(rule__LetExpressionVariableDeclaration__Group_0_1_2__0)
{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getGroup_0_1_2()); }
)
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getGroup_0_1_2()); }
(rule__LetExpressionVariableDeclaration__Group_0_1_2__0)*
{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getGroup_0_1_2()); }
)
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LetExpressionVariableDeclaration__Group_0_1__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LetExpressionVariableDeclaration__Group_0_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__Group_0_1__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getRightParenthesisKeyword_0_1_3()); }

	')' 

{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getRightParenthesisKeyword_0_1_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__LetExpressionVariableDeclaration__Group_0_1_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LetExpressionVariableDeclaration__Group_0_1_2__0__Impl
	rule__LetExpressionVariableDeclaration__Group_0_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__Group_0_1_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getCommaKeyword_0_1_2_0()); }

	',' 

{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getCommaKeyword_0_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LetExpressionVariableDeclaration__Group_0_1_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LetExpressionVariableDeclaration__Group_0_1_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__Group_0_1_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getPartsAssignment_0_1_2_1()); }
(rule__LetExpressionVariableDeclaration__PartsAssignment_0_1_2_1)
{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getPartsAssignment_0_1_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__IfExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfExpression__Group__0__Impl
	rule__IfExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IfExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfExpressionAccess().getStaticAssignment_0()); }
(rule__IfExpression__StaticAssignment_0)?
{ after(grammarAccess.getIfExpressionAccess().getStaticAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IfExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfExpression__Group__1__Impl
	rule__IfExpression__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__IfExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfExpressionAccess().getIfKeyword_1()); }

	'if' 

{ after(grammarAccess.getIfExpressionAccess().getIfKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IfExpression__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfExpression__Group__2__Impl
	rule__IfExpression__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__IfExpression__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfExpressionAccess().getConditionAssignment_2()); }
(rule__IfExpression__ConditionAssignment_2)
{ after(grammarAccess.getIfExpressionAccess().getConditionAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IfExpression__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfExpression__Group__3__Impl
	rule__IfExpression__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__IfExpression__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfExpressionAccess().getThenKeyword_3()); }

	'then' 

{ after(grammarAccess.getIfExpressionAccess().getThenKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IfExpression__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfExpression__Group__4__Impl
	rule__IfExpression__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__IfExpression__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfExpressionAccess().getThenExpressionAssignment_4()); }
(rule__IfExpression__ThenExpressionAssignment_4)
{ after(grammarAccess.getIfExpressionAccess().getThenExpressionAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IfExpression__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfExpression__Group__5__Impl
	rule__IfExpression__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__IfExpression__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfExpressionAccess().getElseKeyword_5()); }

	'else' 

{ after(grammarAccess.getIfExpressionAccess().getElseKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IfExpression__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfExpression__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IfExpression__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfExpressionAccess().getElseExpressionAssignment_6()); }
(rule__IfExpression__ElseExpressionAssignment_6)
{ after(grammarAccess.getIfExpressionAccess().getElseExpressionAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__SwitchExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SwitchExpression__Group__0__Impl
	rule__SwitchExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchExpressionAccess().getStaticAssignment_0()); }
(rule__SwitchExpression__StaticAssignment_0)?
{ after(grammarAccess.getSwitchExpressionAccess().getStaticAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SwitchExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SwitchExpression__Group__1__Impl
	rule__SwitchExpression__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_1()); }

	'switch' 

{ after(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SwitchExpression__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SwitchExpression__Group__2__Impl
	rule__SwitchExpression__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchExpression__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchExpressionAccess().getControlExpressionAssignment_2()); }
(rule__SwitchExpression__ControlExpressionAssignment_2)
{ after(grammarAccess.getSwitchExpressionAccess().getControlExpressionAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SwitchExpression__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SwitchExpression__Group__3__Impl
	rule__SwitchExpression__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchExpression__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchExpressionAccess().getCasesAssignment_3()); }
(rule__SwitchExpression__CasesAssignment_3)*
{ after(grammarAccess.getSwitchExpressionAccess().getCasesAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SwitchExpression__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SwitchExpression__Group__4__Impl
	rule__SwitchExpression__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchExpression__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); }

	'default' 

{ after(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SwitchExpression__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SwitchExpression__Group__5__Impl
	rule__SwitchExpression__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchExpression__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); }

	':' 

{ after(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SwitchExpression__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SwitchExpression__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchExpression__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchExpressionAccess().getDefaultExpressionAssignment_6()); }
(rule__SwitchExpression__DefaultExpressionAssignment_6)
{ after(grammarAccess.getSwitchExpressionAccess().getDefaultExpressionAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__SwitchCase__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SwitchCase__Group__0__Impl
	rule__SwitchCase__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchCase__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchCaseAccess().getCaseKeyword_0()); }

	'case' 

{ after(grammarAccess.getSwitchCaseAccess().getCaseKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SwitchCase__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SwitchCase__Group__1__Impl
	rule__SwitchCase__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchCase__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchCaseAccess().getCaseExpressionAssignment_1()); }
(rule__SwitchCase__CaseExpressionAssignment_1)
{ after(grammarAccess.getSwitchCaseAccess().getCaseExpressionAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SwitchCase__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SwitchCase__Group__2__Impl
	rule__SwitchCase__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchCase__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchCaseAccess().getColonKeyword_2()); }

	':' 

{ after(grammarAccess.getSwitchCaseAccess().getColonKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SwitchCase__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SwitchCase__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchCase__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchCaseAccess().getResultExpressionAssignment_3()); }
(rule__SwitchCase__ResultExpressionAssignment_3)
{ after(grammarAccess.getSwitchCaseAccess().getResultExpressionAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__RangeExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RangeExpression__Group__0__Impl
	rule__RangeExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeExpressionAccess().getImpliesExpressionParserRuleCall_0()); }
	ruleImpliesExpression
{ after(grammarAccess.getRangeExpressionAccess().getImpliesExpressionParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RangeExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RangeExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeExpressionAccess().getGroup_1()); }
(rule__RangeExpression__Group_1__0)?
{ after(grammarAccess.getRangeExpressionAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RangeExpression__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RangeExpression__Group_1__0__Impl
	rule__RangeExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeExpression__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeExpressionAccess().getRangeExpressionOperandsAction_1_0()); }
(

)
{ after(grammarAccess.getRangeExpressionAccess().getRangeExpressionOperandsAction_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RangeExpression__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RangeExpression__Group_1__1__Impl
	rule__RangeExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeExpression__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeExpressionAccess().getColonKeyword_1_1()); }

	':' 

{ after(grammarAccess.getRangeExpressionAccess().getColonKeyword_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RangeExpression__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RangeExpression__Group_1__2__Impl
	rule__RangeExpression__Group_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeExpression__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeExpressionAccess().getOperandsAssignment_1_2()); }
(rule__RangeExpression__OperandsAssignment_1_2)
{ after(grammarAccess.getRangeExpressionAccess().getOperandsAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RangeExpression__Group_1__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RangeExpression__Group_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeExpression__Group_1__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeExpressionAccess().getGroup_1_3()); }
(rule__RangeExpression__Group_1_3__0)?
{ after(grammarAccess.getRangeExpressionAccess().getGroup_1_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__RangeExpression__Group_1_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RangeExpression__Group_1_3__0__Impl
	rule__RangeExpression__Group_1_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeExpression__Group_1_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeExpressionAccess().getColonKeyword_1_3_0()); }

	':' 

{ after(grammarAccess.getRangeExpressionAccess().getColonKeyword_1_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RangeExpression__Group_1_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RangeExpression__Group_1_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeExpression__Group_1_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeExpressionAccess().getOperandsAssignment_1_3_1()); }
(rule__RangeExpression__OperandsAssignment_1_3_1)
{ after(grammarAccess.getRangeExpressionAccess().getOperandsAssignment_1_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ImpliesExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ImpliesExpression__Group__0__Impl
	rule__ImpliesExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ImpliesExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImpliesExpressionAccess().getLogicalOrExpressionParserRuleCall_0()); }
	ruleLogicalOrExpression
{ after(grammarAccess.getImpliesExpressionAccess().getLogicalOrExpressionParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ImpliesExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ImpliesExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ImpliesExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImpliesExpressionAccess().getGroup_1()); }
(rule__ImpliesExpression__Group_1__0)?
{ after(grammarAccess.getImpliesExpressionAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ImpliesExpression__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ImpliesExpression__Group_1__0__Impl
	rule__ImpliesExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ImpliesExpression__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImpliesExpressionAccess().getImpliesExpressionLeftOperandAction_1_0()); }
(

)
{ after(grammarAccess.getImpliesExpressionAccess().getImpliesExpressionLeftOperandAction_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ImpliesExpression__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ImpliesExpression__Group_1__1__Impl
	rule__ImpliesExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ImpliesExpression__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImpliesExpressionAccess().getEqualsSignGreaterThanSignKeyword_1_1()); }

	'=>' 

{ after(grammarAccess.getImpliesExpressionAccess().getEqualsSignGreaterThanSignKeyword_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ImpliesExpression__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ImpliesExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ImpliesExpression__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImpliesExpressionAccess().getRightOperandAssignment_1_2()); }
(rule__ImpliesExpression__RightOperandAssignment_1_2)
{ after(grammarAccess.getImpliesExpressionAccess().getRightOperandAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__LogicalOrExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalOrExpression__Group__0__Impl
	rule__LogicalOrExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalOrExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalOrExpressionAccess().getLogicalAndExpressionParserRuleCall_0()); }
	ruleLogicalAndExpression
{ after(grammarAccess.getLogicalOrExpressionAccess().getLogicalAndExpressionParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LogicalOrExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalOrExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalOrExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalOrExpressionAccess().getGroup_1()); }
(rule__LogicalOrExpression__Group_1__0)*
{ after(grammarAccess.getLogicalOrExpressionAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__LogicalOrExpression__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalOrExpression__Group_1__0__Impl
	rule__LogicalOrExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalOrExpression__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalOrExpressionAccess().getLogicalOrExpressionLeftOperandAction_1_0()); }
(

)
{ after(grammarAccess.getLogicalOrExpressionAccess().getLogicalOrExpressionLeftOperandAction_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LogicalOrExpression__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalOrExpression__Group_1__1__Impl
	rule__LogicalOrExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalOrExpression__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalOrExpressionAccess().getVerticalLineVerticalLineKeyword_1_1()); }

	'||' 

{ after(grammarAccess.getLogicalOrExpressionAccess().getVerticalLineVerticalLineKeyword_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LogicalOrExpression__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalOrExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalOrExpression__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalOrExpressionAccess().getRightOperandAssignment_1_2()); }
(rule__LogicalOrExpression__RightOperandAssignment_1_2)
{ after(grammarAccess.getLogicalOrExpressionAccess().getRightOperandAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__LogicalAndExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalAndExpression__Group__0__Impl
	rule__LogicalAndExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalAndExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalAndExpressionAccess().getEqualityExpressionParserRuleCall_0()); }
	ruleEqualityExpression
{ after(grammarAccess.getLogicalAndExpressionAccess().getEqualityExpressionParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LogicalAndExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalAndExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalAndExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalAndExpressionAccess().getGroup_1()); }
(rule__LogicalAndExpression__Group_1__0)*
{ after(grammarAccess.getLogicalAndExpressionAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__LogicalAndExpression__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalAndExpression__Group_1__0__Impl
	rule__LogicalAndExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalAndExpression__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalAndExpressionAccess().getLogicalAndExpressionLeftOperandAction_1_0()); }
(

)
{ after(grammarAccess.getLogicalAndExpressionAccess().getLogicalAndExpressionLeftOperandAction_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LogicalAndExpression__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalAndExpression__Group_1__1__Impl
	rule__LogicalAndExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalAndExpression__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalAndExpressionAccess().getAmpersandAmpersandKeyword_1_1()); }

	'&&' 

{ after(grammarAccess.getLogicalAndExpressionAccess().getAmpersandAmpersandKeyword_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LogicalAndExpression__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalAndExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalAndExpression__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalAndExpressionAccess().getRightOperandAssignment_1_2()); }
(rule__LogicalAndExpression__RightOperandAssignment_1_2)
{ after(grammarAccess.getLogicalAndExpressionAccess().getRightOperandAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__EqualityExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EqualityExpression__Group__0__Impl
	rule__EqualityExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EqualityExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEqualityExpressionAccess().getRelationalExpressionParserRuleCall_0()); }
	ruleRelationalExpression
{ after(grammarAccess.getEqualityExpressionAccess().getRelationalExpressionParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EqualityExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EqualityExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EqualityExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEqualityExpressionAccess().getGroup_1()); }
(rule__EqualityExpression__Group_1__0)*
{ after(grammarAccess.getEqualityExpressionAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__EqualityExpression__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EqualityExpression__Group_1__0__Impl
	rule__EqualityExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EqualityExpression__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEqualityExpressionAccess().getEqualityExpressionLeftOperandAction_1_0()); }
(

)
{ after(grammarAccess.getEqualityExpressionAccess().getEqualityExpressionLeftOperandAction_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EqualityExpression__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EqualityExpression__Group_1__1__Impl
	rule__EqualityExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__EqualityExpression__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEqualityExpressionAccess().getOperatorAssignment_1_1()); }
(rule__EqualityExpression__OperatorAssignment_1_1)
{ after(grammarAccess.getEqualityExpressionAccess().getOperatorAssignment_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EqualityExpression__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EqualityExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EqualityExpression__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEqualityExpressionAccess().getRightOperandAssignment_1_2()); }
(rule__EqualityExpression__RightOperandAssignment_1_2)
{ after(grammarAccess.getEqualityExpressionAccess().getRightOperandAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__RelationalExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RelationalExpression__Group__0__Impl
	rule__RelationalExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); }
	ruleAdditiveExpression
{ after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RelationalExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RelationalExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); }
(rule__RelationalExpression__Group_1__0)?
{ after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RelationalExpression__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RelationalExpression__Group_1__0__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalExpression__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalExpressionAccess().getAlternatives_1_0()); }
(rule__RelationalExpression__Alternatives_1_0)
{ after(grammarAccess.getRelationalExpressionAccess().getAlternatives_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}




rule__RelationalExpression__Group_1_0_0__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RelationalExpression__Group_1_0_0__0__Impl
	rule__RelationalExpression__Group_1_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalExpression__Group_1_0_0__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalExpressionAccess().getRelationalExpressionLeftOperandAction_1_0_0_0()); }
(

)
{ after(grammarAccess.getRelationalExpressionAccess().getRelationalExpressionLeftOperandAction_1_0_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RelationalExpression__Group_1_0_0__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RelationalExpression__Group_1_0_0__1__Impl
	rule__RelationalExpression__Group_1_0_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalExpression__Group_1_0_0__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_0_0_1()); }
(rule__RelationalExpression__OperatorAssignment_1_0_0_1)
{ after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_0_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RelationalExpression__Group_1_0_0__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RelationalExpression__Group_1_0_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalExpression__Group_1_0_0__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalExpressionAccess().getRightOperandAssignment_1_0_0_2()); }
(rule__RelationalExpression__RightOperandAssignment_1_0_0_2)
{ after(grammarAccess.getRelationalExpressionAccess().getRightOperandAssignment_1_0_0_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__RelationalExpression__Group_1_0_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RelationalExpression__Group_1_0_1__0__Impl
	rule__RelationalExpression__Group_1_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalExpression__Group_1_0_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalExpressionAccess().getTypeTestExpressionExpressionAction_1_0_1_0()); }
(

)
{ after(grammarAccess.getRelationalExpressionAccess().getTypeTestExpressionExpressionAction_1_0_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RelationalExpression__Group_1_0_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RelationalExpression__Group_1_0_1__1__Impl
	rule__RelationalExpression__Group_1_0_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalExpression__Group_1_0_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalExpressionAccess().getIsKeyword_1_0_1_1()); }

	'is' 

{ after(grammarAccess.getRelationalExpressionAccess().getIsKeyword_1_0_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RelationalExpression__Group_1_0_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RelationalExpression__Group_1_0_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalExpression__Group_1_0_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalExpressionAccess().getTypeAssignment_1_0_1_2()); }
(rule__RelationalExpression__TypeAssignment_1_0_1_2)
{ after(grammarAccess.getRelationalExpressionAccess().getTypeAssignment_1_0_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().getAdditiveExpressionLeftOperandAction_1_0()); }
(

)
{ after(grammarAccess.getAdditiveExpressionAccess().getAdditiveExpressionLeftOperandAction_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().getOperatorAssignment_1_1()); }
(rule__AdditiveExpression__OperatorAssignment_1_1)
{ after(grammarAccess.getAdditiveExpressionAccess().getOperatorAssignment_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().getRightOperandAssignment_1_2()); }
(rule__AdditiveExpression__RightOperandAssignment_1_2)
{ after(grammarAccess.getAdditiveExpressionAccess().getRightOperandAssignment_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().getPowerExpressionParserRuleCall_0()); }
	rulePowerExpression
{ after(grammarAccess.getMultiplicativeExpressionAccess().getPowerExpressionParserRuleCall_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().getMultiplicativeExpressionLeftOperandAction_1_0()); }
(

)
{ after(grammarAccess.getMultiplicativeExpressionAccess().getMultiplicativeExpressionLeftOperandAction_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().getOperatorAssignment_1_1()); }
(rule__MultiplicativeExpression__OperatorAssignment_1_1)
{ after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorAssignment_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().getRightOperandAssignment_1_2()); }
(rule__MultiplicativeExpression__RightOperandAssignment_1_2)
{ after(grammarAccess.getMultiplicativeExpressionAccess().getRightOperandAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__PowerExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PowerExpression__Group__0__Impl
	rule__PowerExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PowerExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPowerExpressionAccess().getUnaryExpressionParserRuleCall_0()); }
	ruleUnaryExpression
{ after(grammarAccess.getPowerExpressionAccess().getUnaryExpressionParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PowerExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PowerExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PowerExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPowerExpressionAccess().getGroup_1()); }
(rule__PowerExpression__Group_1__0)?
{ after(grammarAccess.getPowerExpressionAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__PowerExpression__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PowerExpression__Group_1__0__Impl
	rule__PowerExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PowerExpression__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPowerExpressionAccess().getPowerExpressionOperandAction_1_0()); }
(

)
{ after(grammarAccess.getPowerExpressionAccess().getPowerExpressionOperandAction_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PowerExpression__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PowerExpression__Group_1__1__Impl
	rule__PowerExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PowerExpression__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPowerExpressionAccess().getOperatorAssignment_1_1()); }
(rule__PowerExpression__OperatorAssignment_1_1)
{ after(grammarAccess.getPowerExpressionAccess().getOperatorAssignment_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PowerExpression__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PowerExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PowerExpression__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPowerExpressionAccess().getExponentAssignment_1_2()); }
(rule__PowerExpression__ExponentAssignment_1_2)
{ after(grammarAccess.getPowerExpressionAccess().getExponentAssignment_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().getOperatorAssignment_1_1()); }
(rule__UnaryExpression__OperatorAssignment_1_1)
{ after(grammarAccess.getUnaryExpressionAccess().getOperatorAssignment_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().getOperandAssignment_1_2()); }
(rule__UnaryExpression__OperandAssignment_1_2)
{ after(grammarAccess.getUnaryExpressionAccess().getOperandAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__PostfixExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PostfixExpression__Group__0__Impl
	rule__PostfixExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PostfixExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPostfixExpressionAccess().getArrayElementAccessParserRuleCall_0()); }
	ruleArrayElementAccess
{ after(grammarAccess.getPostfixExpressionAccess().getArrayElementAccessParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PostfixExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PostfixExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PostfixExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPostfixExpressionAccess().getGroup_1()); }
(rule__PostfixExpression__Group_1__0)?
{ after(grammarAccess.getPostfixExpressionAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__PostfixExpression__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PostfixExpression__Group_1__0__Impl
	rule__PostfixExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PostfixExpression__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPostfixExpressionAccess().getPostfixExpressionOperandAction_1_0()); }
(

)
{ after(grammarAccess.getPostfixExpressionAccess().getPostfixExpressionOperandAction_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PostfixExpression__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PostfixExpression__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PostfixExpression__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPostfixExpressionAccess().getOperatorAssignment_1_1()); }
(rule__PostfixExpression__OperatorAssignment_1_1)
{ after(grammarAccess.getPostfixExpressionAccess().getOperatorAssignment_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ArrayElementAccess__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayElementAccess__Group__0__Impl
	rule__ArrayElementAccess__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayElementAccess__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayElementAccessAccess().getMemberFeatureCallParserRuleCall_0()); }
	ruleMemberFeatureCall
{ after(grammarAccess.getArrayElementAccessAccess().getMemberFeatureCallParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayElementAccess__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayElementAccess__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayElementAccess__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayElementAccessAccess().getGroup_1()); }
(rule__ArrayElementAccess__Group_1__0)*
{ after(grammarAccess.getArrayElementAccessAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ArrayElementAccess__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayElementAccess__Group_1__0__Impl
	rule__ArrayElementAccess__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayElementAccess__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayElementAccessAccess().getArrayElementAccessArrayAction_1_0()); }
(

)
{ after(grammarAccess.getArrayElementAccessAccess().getArrayElementAccessArrayAction_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayElementAccess__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayElementAccess__Group_1__1__Impl
	rule__ArrayElementAccess__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayElementAccess__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayElementAccessAccess().getLeftSquareBracketKeyword_1_1()); }

	'[' 

{ after(grammarAccess.getArrayElementAccessAccess().getLeftSquareBracketKeyword_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayElementAccess__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayElementAccess__Group_1__2__Impl
	rule__ArrayElementAccess__Group_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayElementAccess__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayElementAccessAccess().getSubscriptsAssignment_1_2()); }
(rule__ArrayElementAccess__SubscriptsAssignment_1_2)
{ after(grammarAccess.getArrayElementAccessAccess().getSubscriptsAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayElementAccess__Group_1__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayElementAccess__Group_1__3__Impl
	rule__ArrayElementAccess__Group_1__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayElementAccess__Group_1__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayElementAccessAccess().getGroup_1_3()); }
(rule__ArrayElementAccess__Group_1_3__0)*
{ after(grammarAccess.getArrayElementAccessAccess().getGroup_1_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayElementAccess__Group_1__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayElementAccess__Group_1__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayElementAccess__Group_1__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayElementAccessAccess().getRightSquareBracketKeyword_1_4()); }

	']' 

{ after(grammarAccess.getArrayElementAccessAccess().getRightSquareBracketKeyword_1_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__ArrayElementAccess__Group_1_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayElementAccess__Group_1_3__0__Impl
	rule__ArrayElementAccess__Group_1_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayElementAccess__Group_1_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayElementAccessAccess().getCommaKeyword_1_3_0()); }

	',' 

{ after(grammarAccess.getArrayElementAccessAccess().getCommaKeyword_1_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayElementAccess__Group_1_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayElementAccess__Group_1_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayElementAccess__Group_1_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayElementAccessAccess().getSubscriptsAssignment_1_3_1()); }
(rule__ArrayElementAccess__SubscriptsAssignment_1_3_1)
{ after(grammarAccess.getArrayElementAccessAccess().getSubscriptsAssignment_1_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__MemberFeatureCall__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group__0__Impl
	rule__MemberFeatureCall__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getPrimaryExpressionParserRuleCall_0()); }
	rulePrimaryExpression
{ after(grammarAccess.getMemberFeatureCallAccess().getPrimaryExpressionParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getAlternatives_1()); }
(rule__MemberFeatureCall__Alternatives_1)*
{ after(grammarAccess.getMemberFeatureCallAccess().getAlternatives_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__MemberFeatureCall__Group_1_0__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_0__0__Impl
	rule__MemberFeatureCall__Group_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_0__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getMemberVariableAccessTargetAction_1_0_0()); }
(

)
{ after(grammarAccess.getMemberFeatureCallAccess().getMemberVariableAccessTargetAction_1_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_0__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_0__1__Impl
	rule__MemberFeatureCall__Group_1_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_0__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getFullStopKeyword_1_0_1()); }

	'.' 

{ after(grammarAccess.getMemberFeatureCallAccess().getFullStopKeyword_1_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_0__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_0__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getMemberVariableAssignment_1_0_2()); }
(rule__MemberFeatureCall__MemberVariableAssignment_1_0_2)
{ after(grammarAccess.getMemberFeatureCallAccess().getMemberVariableAssignment_1_0_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__MemberFeatureCall__Group_1_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_1__0__Impl
	rule__MemberFeatureCall__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getFunctionCallArgumentsAction_1_1_0()); }
(

)
{ after(grammarAccess.getMemberFeatureCallAccess().getFunctionCallArgumentsAction_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_1__1__Impl
	rule__MemberFeatureCall__Group_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getFullStopKeyword_1_1_1()); }

	'.' 

{ after(grammarAccess.getMemberFeatureCallAccess().getFullStopKeyword_1_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_1__2__Impl
	rule__MemberFeatureCall__Group_1_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); }
(rule__MemberFeatureCall__FeatureAssignment_1_1_2)
{ after(grammarAccess.getMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_1__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_1__3__Impl
	rule__MemberFeatureCall__Group_1_1__4
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_1__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getLeftParenthesisKeyword_1_1_3()); }

	'(' 

{ after(grammarAccess.getMemberFeatureCallAccess().getLeftParenthesisKeyword_1_1_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_1__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_1__4__Impl
	rule__MemberFeatureCall__Group_1_1__5
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_1__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getGroup_1_1_4()); }
(rule__MemberFeatureCall__Group_1_1_4__0)?
{ after(grammarAccess.getMemberFeatureCallAccess().getGroup_1_1_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_1__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_1__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_1__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_5()); }

	')' 

{ after(grammarAccess.getMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}














rule__MemberFeatureCall__Group_1_1_4__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_1_4__0__Impl
	rule__MemberFeatureCall__Group_1_1_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_1_4__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getArgumentsAssignment_1_1_4_0()); }
(rule__MemberFeatureCall__ArgumentsAssignment_1_1_4_0)
{ after(grammarAccess.getMemberFeatureCallAccess().getArgumentsAssignment_1_1_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_1_4__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_1_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_1_4__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getGroup_1_1_4_1()); }
(rule__MemberFeatureCall__Group_1_1_4_1__0)*
{ after(grammarAccess.getMemberFeatureCallAccess().getGroup_1_1_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__MemberFeatureCall__Group_1_1_4_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_1_4_1__0__Impl
	rule__MemberFeatureCall__Group_1_1_4_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_1_4_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getCommaKeyword_1_1_4_1_0()); }

	',' 

{ after(grammarAccess.getMemberFeatureCallAccess().getCommaKeyword_1_1_4_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_1_4_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_1_4_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_1_4_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getArgumentsAssignment_1_1_4_1_1()); }
(rule__MemberFeatureCall__ArgumentsAssignment_1_1_4_1_1)
{ after(grammarAccess.getMemberFeatureCallAccess().getArgumentsAssignment_1_1_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__MemberFeatureCall__Group_1_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2__0__Impl
	rule__MemberFeatureCall__Group_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getIterationCallTargetAction_1_2_0()); }
(

)
{ after(grammarAccess.getMemberFeatureCallAccess().getIterationCallTargetAction_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2__1__Impl
	rule__MemberFeatureCall__Group_1_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getFullStopKeyword_1_2_1()); }

	'.' 

{ after(grammarAccess.getMemberFeatureCallAccess().getFullStopKeyword_1_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_2__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2__2__Impl
	rule__MemberFeatureCall__Group_1_2__3
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getIdentifierAssignment_1_2_2()); }
(rule__MemberFeatureCall__IdentifierAssignment_1_2_2)
{ after(grammarAccess.getMemberFeatureCallAccess().getIdentifierAssignment_1_2_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_2__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2__3__Impl
	rule__MemberFeatureCall__Group_1_2__4
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getLeftParenthesisKeyword_1_2_3()); }

	'(' 

{ after(grammarAccess.getMemberFeatureCallAccess().getLeftParenthesisKeyword_1_2_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_2__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2__4__Impl
	rule__MemberFeatureCall__Group_1_2__5
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getVariablesAssignment_1_2_4()); }
(rule__MemberFeatureCall__VariablesAssignment_1_2_4)
{ after(grammarAccess.getMemberFeatureCallAccess().getVariablesAssignment_1_2_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_2__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2__5__Impl
	rule__MemberFeatureCall__Group_1_2__6
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getGroup_1_2_5()); }
(rule__MemberFeatureCall__Group_1_2_5__0)*
{ after(grammarAccess.getMemberFeatureCallAccess().getGroup_1_2_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_2__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2__6__Impl
	rule__MemberFeatureCall__Group_1_2__7
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getGroup_1_2_6()); }
(rule__MemberFeatureCall__Group_1_2_6__0)?
{ after(grammarAccess.getMemberFeatureCallAccess().getGroup_1_2_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_2__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2__7__Impl
	rule__MemberFeatureCall__Group_1_2__8
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getGroup_1_2_7()); }
(rule__MemberFeatureCall__Group_1_2_7__0)?
{ after(grammarAccess.getMemberFeatureCallAccess().getGroup_1_2_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_2__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2__8__Impl
	rule__MemberFeatureCall__Group_1_2__9
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getVerticalLineKeyword_1_2_8()); }

	'|' 

{ after(grammarAccess.getMemberFeatureCallAccess().getVerticalLineKeyword_1_2_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_2__9
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2__9__Impl
	rule__MemberFeatureCall__Group_1_2__10
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2__9__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getExpressionAssignment_1_2_9()); }
(rule__MemberFeatureCall__ExpressionAssignment_1_2_9)
{ after(grammarAccess.getMemberFeatureCallAccess().getExpressionAssignment_1_2_9()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_2__10
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2__10__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2__10__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getRightParenthesisKeyword_1_2_10()); }

	')' 

{ after(grammarAccess.getMemberFeatureCallAccess().getRightParenthesisKeyword_1_2_10()); }
)

;
finally {
	restoreStackSize(stackSize);
}
























rule__MemberFeatureCall__Group_1_2_5__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2_5__0__Impl
	rule__MemberFeatureCall__Group_1_2_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2_5__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getCommaKeyword_1_2_5_0()); }

	',' 

{ after(grammarAccess.getMemberFeatureCallAccess().getCommaKeyword_1_2_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_2_5__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2_5__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2_5__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getVariablesAssignment_1_2_5_1()); }
(rule__MemberFeatureCall__VariablesAssignment_1_2_5_1)
{ after(grammarAccess.getMemberFeatureCallAccess().getVariablesAssignment_1_2_5_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__MemberFeatureCall__Group_1_2_6__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2_6__0__Impl
	rule__MemberFeatureCall__Group_1_2_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2_6__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getSemicolonKeyword_1_2_6_0()); }

	';' 

{ after(grammarAccess.getMemberFeatureCallAccess().getSemicolonKeyword_1_2_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_2_6__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2_6__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2_6__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getAccumulatorAssignment_1_2_6_1()); }
(rule__MemberFeatureCall__AccumulatorAssignment_1_2_6_1)
{ after(grammarAccess.getMemberFeatureCallAccess().getAccumulatorAssignment_1_2_6_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__MemberFeatureCall__Group_1_2_7__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2_7__0__Impl
	rule__MemberFeatureCall__Group_1_2_7__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2_7__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getSemicolonKeyword_1_2_7_0()); }

	';' 

{ after(grammarAccess.getMemberFeatureCallAccess().getSemicolonKeyword_1_2_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MemberFeatureCall__Group_1_2_7__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MemberFeatureCall__Group_1_2_7__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__Group_1_2_7__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getBreakConditionAssignment_1_2_7_1()); }
(rule__MemberFeatureCall__BreakConditionAssignment_1_2_7_1)
{ after(grammarAccess.getMemberFeatureCallAccess().getBreakConditionAssignment_1_2_7_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__AssignableMemberFeatureCall__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AssignableMemberFeatureCall__Group__0__Impl
	rule__AssignableMemberFeatureCall__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AssignableMemberFeatureCall__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssignableMemberFeatureCallAccess().getAssignablePrimaryExpressionParserRuleCall_0()); }
	ruleAssignablePrimaryExpression
{ after(grammarAccess.getAssignableMemberFeatureCallAccess().getAssignablePrimaryExpressionParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AssignableMemberFeatureCall__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AssignableMemberFeatureCall__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AssignableMemberFeatureCall__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssignableMemberFeatureCallAccess().getGroup_1()); }
(rule__AssignableMemberFeatureCall__Group_1__0)*
{ after(grammarAccess.getAssignableMemberFeatureCallAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__AssignableMemberFeatureCall__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AssignableMemberFeatureCall__Group_1__0__Impl
	rule__AssignableMemberFeatureCall__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AssignableMemberFeatureCall__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssignableMemberFeatureCallAccess().getMemberVariableAccessTargetAction_1_0()); }
(

)
{ after(grammarAccess.getAssignableMemberFeatureCallAccess().getMemberVariableAccessTargetAction_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AssignableMemberFeatureCall__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AssignableMemberFeatureCall__Group_1__1__Impl
	rule__AssignableMemberFeatureCall__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AssignableMemberFeatureCall__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssignableMemberFeatureCallAccess().getFullStopKeyword_1_1()); }

	'.' 

{ after(grammarAccess.getAssignableMemberFeatureCallAccess().getFullStopKeyword_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AssignableMemberFeatureCall__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AssignableMemberFeatureCall__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AssignableMemberFeatureCall__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssignableMemberFeatureCallAccess().getMemberVariableAssignment_1_2()); }
(rule__AssignableMemberFeatureCall__MemberVariableAssignment_1_2)
{ after(grammarAccess.getAssignableMemberFeatureCallAccess().getMemberVariableAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__IterationAccumulator__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IterationAccumulator__Group__0__Impl
	rule__IterationAccumulator__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IterationAccumulator__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIterationAccumulatorAccess().getNameAssignment_0()); }
(rule__IterationAccumulator__NameAssignment_0)
{ after(grammarAccess.getIterationAccumulatorAccess().getNameAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IterationAccumulator__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IterationAccumulator__Group__1__Impl
	rule__IterationAccumulator__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__IterationAccumulator__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIterationAccumulatorAccess().getEqualsSignKeyword_1()); }

	'=' 

{ after(grammarAccess.getIterationAccumulatorAccess().getEqualsSignKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IterationAccumulator__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IterationAccumulator__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IterationAccumulator__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIterationAccumulatorAccess().getInitializerAssignment_2()); }
(rule__IterationAccumulator__InitializerAssignment_2)
{ after(grammarAccess.getIterationAccumulatorAccess().getInitializerAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__RealLiteral__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RealLiteral__Group__0__Impl
	rule__RealLiteral__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RealLiteral__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealLiteralAccess().getValueAssignment_0()); }
(rule__RealLiteral__ValueAssignment_0)
{ after(grammarAccess.getRealLiteralAccess().getValueAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RealLiteral__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RealLiteral__Group__1__Impl
	rule__RealLiteral__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RealLiteral__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealLiteralAccess().getModifierAssignment_1()); }
(rule__RealLiteral__ModifierAssignment_1)?
{ after(grammarAccess.getRealLiteralAccess().getModifierAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RealLiteral__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RealLiteral__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RealLiteral__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealLiteralAccess().getUnitAssignment_2()); }
(rule__RealLiteral__UnitAssignment_2)
{ after(grammarAccess.getRealLiteralAccess().getUnitAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__IntegerLiteral__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IntegerLiteral__Group__0__Impl
	rule__IntegerLiteral__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerLiteral__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntegerLiteralAccess().getValueAssignment_0()); }
(rule__IntegerLiteral__ValueAssignment_0)
{ after(grammarAccess.getIntegerLiteralAccess().getValueAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IntegerLiteral__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IntegerLiteral__Group__1__Impl
	rule__IntegerLiteral__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerLiteral__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntegerLiteralAccess().getModifierAssignment_1()); }
(rule__IntegerLiteral__ModifierAssignment_1)?
{ after(grammarAccess.getIntegerLiteralAccess().getModifierAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IntegerLiteral__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IntegerLiteral__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerLiteral__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntegerLiteralAccess().getUnitAssignment_2()); }
(rule__IntegerLiteral__UnitAssignment_2)
{ after(grammarAccess.getIntegerLiteralAccess().getUnitAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__BooleanLiteral__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BooleanLiteral__Group__0__Impl
	rule__BooleanLiteral__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBooleanLiteralAccess().getBooleanLiteralAction_0()); }
(

)
{ after(grammarAccess.getBooleanLiteralAccess().getBooleanLiteralAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__BooleanLiteral__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BooleanLiteral__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBooleanLiteralAccess().getAlternatives_1()); }
(rule__BooleanLiteral__Alternatives_1)
{ after(grammarAccess.getBooleanLiteralAccess().getAlternatives_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__VariableAccess__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VariableAccess__Group__0__Impl
	rule__VariableAccess__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableAccess__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableAccessAccess().getVariableAccessAction_0()); }
(

)
{ after(grammarAccess.getVariableAccessAccess().getVariableAccessAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__VariableAccess__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VariableAccess__Group__1__Impl
	rule__VariableAccess__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableAccess__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableAccessAccess().getFeatureAssignment_1()); }
(rule__VariableAccess__FeatureAssignment_1)
{ after(grammarAccess.getVariableAccessAccess().getFeatureAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__VariableAccess__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VariableAccess__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableAccess__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableAccessAccess().getGroup_2()); }
(rule__VariableAccess__Group_2__0)?
{ after(grammarAccess.getVariableAccessAccess().getGroup_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__VariableAccess__Group_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VariableAccess__Group_2__0__Impl
	rule__VariableAccess__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableAccess__Group_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableAccessAccess().getLeftCurlyBracketKeyword_2_0()); }

	'{' 

{ after(grammarAccess.getVariableAccessAccess().getLeftCurlyBracketKeyword_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__VariableAccess__Group_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VariableAccess__Group_2__1__Impl
	rule__VariableAccess__Group_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableAccess__Group_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableAccessAccess().getStepExpressionAssignment_2_1()); }
(rule__VariableAccess__StepExpressionAssignment_2_1)
{ after(grammarAccess.getVariableAccessAccess().getStepExpressionAssignment_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__VariableAccess__Group_2__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VariableAccess__Group_2__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableAccess__Group_2__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableAccessAccess().getRightCurlyBracketKeyword_2_2()); }

	'}' 

{ after(grammarAccess.getVariableAccessAccess().getRightCurlyBracketKeyword_2_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__FunctionCall__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionCall__Group__0__Impl
	rule__FunctionCall__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionCall__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionCallAccess().getFunctionCallAction_0()); }
(

)
{ after(grammarAccess.getFunctionCallAccess().getFunctionCallAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionCall__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionCall__Group__1__Impl
	rule__FunctionCall__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionCall__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionCallAccess().getFeatureAssignment_1()); }
(rule__FunctionCall__FeatureAssignment_1)
{ after(grammarAccess.getFunctionCallAccess().getFeatureAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionCall__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionCall__Group__2__Impl
	rule__FunctionCall__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionCall__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionCallAccess().getLeftParenthesisKeyword_2()); }

	'(' 

{ after(grammarAccess.getFunctionCallAccess().getLeftParenthesisKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionCall__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionCall__Group__3__Impl
	rule__FunctionCall__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionCall__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionCallAccess().getGroup_3()); }
(rule__FunctionCall__Group_3__0)?
{ after(grammarAccess.getFunctionCallAccess().getGroup_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionCall__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionCall__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionCall__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionCallAccess().getRightParenthesisKeyword_4()); }

	')' 

{ after(grammarAccess.getFunctionCallAccess().getRightParenthesisKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__FunctionCall__Group_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionCall__Group_3__0__Impl
	rule__FunctionCall__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionCall__Group_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionCallAccess().getArgumentsAssignment_3_0()); }
(rule__FunctionCall__ArgumentsAssignment_3_0)
{ after(grammarAccess.getFunctionCallAccess().getArgumentsAssignment_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionCall__Group_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionCall__Group_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionCall__Group_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionCallAccess().getGroup_3_1()); }
(rule__FunctionCall__Group_3_1__0)*
{ after(grammarAccess.getFunctionCallAccess().getGroup_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__FunctionCall__Group_3_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionCall__Group_3_1__0__Impl
	rule__FunctionCall__Group_3_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionCall__Group_3_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionCallAccess().getCommaKeyword_3_1_0()); }

	',' 

{ after(grammarAccess.getFunctionCallAccess().getCommaKeyword_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionCall__Group_3_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FunctionCall__Group_3_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionCall__Group_3_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionCallAccess().getArgumentsAssignment_3_1_1()); }
(rule__FunctionCall__ArgumentsAssignment_3_1_1)
{ after(grammarAccess.getFunctionCallAccess().getArgumentsAssignment_3_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RangeStepExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RangeStepExpression__Group__0__Impl
	rule__RangeStepExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeStepExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeStepExpressionAccess().getAdditiveStepExpressionParserRuleCall_0()); }
	ruleAdditiveStepExpression
{ after(grammarAccess.getRangeStepExpressionAccess().getAdditiveStepExpressionParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RangeStepExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RangeStepExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeStepExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeStepExpressionAccess().getGroup_1()); }
(rule__RangeStepExpression__Group_1__0)?
{ after(grammarAccess.getRangeStepExpressionAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RangeStepExpression__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RangeStepExpression__Group_1__0__Impl
	rule__RangeStepExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeStepExpression__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeStepExpressionAccess().getRangeStepExpressionStartAction_1_0()); }
(

)
{ after(grammarAccess.getRangeStepExpressionAccess().getRangeStepExpressionStartAction_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RangeStepExpression__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RangeStepExpression__Group_1__1__Impl
	rule__RangeStepExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeStepExpression__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeStepExpressionAccess().getFullStopFullStopKeyword_1_1()); }

	'..' 

{ after(grammarAccess.getRangeStepExpressionAccess().getFullStopFullStopKeyword_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RangeStepExpression__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RangeStepExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeStepExpression__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeStepExpressionAccess().getEndAssignment_1_2()); }
(rule__RangeStepExpression__EndAssignment_1_2)
{ after(grammarAccess.getRangeStepExpressionAccess().getEndAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__AdditiveStepExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AdditiveStepExpression__Group__0__Impl
	rule__AdditiveStepExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveStepExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAdditiveStepExpressionAccess().getNegateStepExpressionParserRuleCall_0()); }
	ruleNegateStepExpression
{ after(grammarAccess.getAdditiveStepExpressionAccess().getNegateStepExpressionParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AdditiveStepExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AdditiveStepExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveStepExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAdditiveStepExpressionAccess().getGroup_1()); }
(rule__AdditiveStepExpression__Group_1__0)*
{ after(grammarAccess.getAdditiveStepExpressionAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__AdditiveStepExpression__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AdditiveStepExpression__Group_1__0__Impl
	rule__AdditiveStepExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveStepExpression__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAdditiveStepExpressionAccess().getAdditiveStepExpressionLeftOperandAction_1_0()); }
(

)
{ after(grammarAccess.getAdditiveStepExpressionAccess().getAdditiveStepExpressionLeftOperandAction_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AdditiveStepExpression__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AdditiveStepExpression__Group_1__1__Impl
	rule__AdditiveStepExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveStepExpression__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAdditiveStepExpressionAccess().getOperatorAssignment_1_1()); }
(rule__AdditiveStepExpression__OperatorAssignment_1_1)
{ after(grammarAccess.getAdditiveStepExpressionAccess().getOperatorAssignment_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AdditiveStepExpression__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AdditiveStepExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveStepExpression__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAdditiveStepExpressionAccess().getRightOperandAssignment_1_2()); }
(rule__AdditiveStepExpression__RightOperandAssignment_1_2)
{ after(grammarAccess.getAdditiveStepExpressionAccess().getRightOperandAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__NegateStepExpression__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__NegateStepExpression__Group_1__0__Impl
	rule__NegateStepExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__NegateStepExpression__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getNegateStepExpressionAccess().getNegateStepExpressionAction_1_0()); }
(

)
{ after(grammarAccess.getNegateStepExpressionAccess().getNegateStepExpressionAction_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__NegateStepExpression__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__NegateStepExpression__Group_1__1__Impl
	rule__NegateStepExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__NegateStepExpression__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getNegateStepExpressionAccess().getHyphenMinusKeyword_1_1()); }

	'-' 

{ after(grammarAccess.getNegateStepExpressionAccess().getHyphenMinusKeyword_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__NegateStepExpression__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__NegateStepExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__NegateStepExpression__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getNegateStepExpressionAccess().getOperandAssignment_1_2()); }
(rule__NegateStepExpression__OperandAssignment_1_2)
{ after(grammarAccess.getNegateStepExpressionAccess().getOperandAssignment_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__StepN__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StepN__Group__0__Impl
	rule__StepN__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StepN__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStepNAccess().getStepNAction_0()); }
(

)
{ after(grammarAccess.getStepNAccess().getStepNAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StepN__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StepN__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StepN__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStepNAccess().getNTerminalRuleCall_1()); }
	RULE_N
{ after(grammarAccess.getStepNAccess().getNTerminalRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__DerivativeOperator__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DerivativeOperator__Group__0__Impl
	rule__DerivativeOperator__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DerivativeOperator__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDerivativeOperatorAccess().getDerKeyword_0()); }

	'der' 

{ after(grammarAccess.getDerivativeOperatorAccess().getDerKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DerivativeOperator__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DerivativeOperator__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DerivativeOperator__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDerivativeOperatorAccess().getVariableAssignment_1()); }
(rule__DerivativeOperator__VariableAssignment_1)
{ after(grammarAccess.getDerivativeOperatorAccess().getVariableAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ArrayConstructionOperator__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionOperator__Group__0__Impl
	rule__ArrayConstructionOperator__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getLeftCurlyBracketKeyword_0()); }

	'{' 

{ after(grammarAccess.getArrayConstructionOperatorAccess().getLeftCurlyBracketKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayConstructionOperator__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionOperator__Group__1__Impl
	rule__ArrayConstructionOperator__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getExpressionsAssignment_1()); }
(rule__ArrayConstructionOperator__ExpressionsAssignment_1)
{ after(grammarAccess.getArrayConstructionOperatorAccess().getExpressionsAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayConstructionOperator__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionOperator__Group__2__Impl
	rule__ArrayConstructionOperator__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getAlternatives_2()); }
(rule__ArrayConstructionOperator__Alternatives_2)
{ after(grammarAccess.getArrayConstructionOperatorAccess().getAlternatives_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayConstructionOperator__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionOperator__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getRightCurlyBracketKeyword_3()); }

	'}' 

{ after(grammarAccess.getArrayConstructionOperatorAccess().getRightCurlyBracketKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__ArrayConstructionOperator__Group_2_0__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionOperator__Group_2_0__0__Impl
	rule__ArrayConstructionOperator__Group_2_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__Group_2_0__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getCommaKeyword_2_0_0()); }

	',' 

{ after(grammarAccess.getArrayConstructionOperatorAccess().getCommaKeyword_2_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayConstructionOperator__Group_2_0__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionOperator__Group_2_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__Group_2_0__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getExpressionsAssignment_2_0_1()); }
(rule__ArrayConstructionOperator__ExpressionsAssignment_2_0_1)
{ after(grammarAccess.getArrayConstructionOperatorAccess().getExpressionsAssignment_2_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ArrayConstructionOperator__Group_2_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionOperator__Group_2_1__0__Impl
	rule__ArrayConstructionOperator__Group_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__Group_2_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getForKeyword_2_1_0()); }

	'for' 

{ after(grammarAccess.getArrayConstructionOperatorAccess().getForKeyword_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayConstructionOperator__Group_2_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionOperator__Group_2_1__1__Impl
	rule__ArrayConstructionOperator__Group_2_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__Group_2_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getIterationClausesAssignment_2_1_1()); }
(rule__ArrayConstructionOperator__IterationClausesAssignment_2_1_1)
{ after(grammarAccess.getArrayConstructionOperatorAccess().getIterationClausesAssignment_2_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayConstructionOperator__Group_2_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionOperator__Group_2_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__Group_2_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getGroup_2_1_2()); }
(rule__ArrayConstructionOperator__Group_2_1_2__0)*
{ after(grammarAccess.getArrayConstructionOperatorAccess().getGroup_2_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__ArrayConstructionOperator__Group_2_1_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionOperator__Group_2_1_2__0__Impl
	rule__ArrayConstructionOperator__Group_2_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__Group_2_1_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getCommaKeyword_2_1_2_0()); }

	',' 

{ after(grammarAccess.getArrayConstructionOperatorAccess().getCommaKeyword_2_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayConstructionOperator__Group_2_1_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionOperator__Group_2_1_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__Group_2_1_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getIterationClausesAssignment_2_1_2_1()); }
(rule__ArrayConstructionOperator__IterationClausesAssignment_2_1_2_1)
{ after(grammarAccess.getArrayConstructionOperatorAccess().getIterationClausesAssignment_2_1_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ArrayConstructionIterationClause__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionIterationClause__Group__0__Impl
	rule__ArrayConstructionIterationClause__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionIterationClause__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionIterationClauseAccess().getVariableNameAssignment_0()); }
(rule__ArrayConstructionIterationClause__VariableNameAssignment_0)
{ after(grammarAccess.getArrayConstructionIterationClauseAccess().getVariableNameAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayConstructionIterationClause__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionIterationClause__Group__1__Impl
	rule__ArrayConstructionIterationClause__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionIterationClause__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionIterationClauseAccess().getInKeyword_1()); }

	'in' 

{ after(grammarAccess.getArrayConstructionIterationClauseAccess().getInKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayConstructionIterationClause__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConstructionIterationClause__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionIterationClause__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionIterationClauseAccess().getCollectionExpressionAssignment_2()); }
(rule__ArrayConstructionIterationClause__CollectionExpressionAssignment_2)
{ after(grammarAccess.getArrayConstructionIterationClauseAccess().getCollectionExpressionAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__ArrayConcatenationOperator__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConcatenationOperator__Group__0__Impl
	rule__ArrayConcatenationOperator__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConcatenationOperator__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConcatenationOperatorAccess().getLeftSquareBracketKeyword_0()); }

	'[' 

{ after(grammarAccess.getArrayConcatenationOperatorAccess().getLeftSquareBracketKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayConcatenationOperator__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConcatenationOperator__Group__1__Impl
	rule__ArrayConcatenationOperator__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConcatenationOperator__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConcatenationOperatorAccess().getRowsAssignment_1()); }
(rule__ArrayConcatenationOperator__RowsAssignment_1)
{ after(grammarAccess.getArrayConcatenationOperatorAccess().getRowsAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayConcatenationOperator__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConcatenationOperator__Group__2__Impl
	rule__ArrayConcatenationOperator__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConcatenationOperator__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConcatenationOperatorAccess().getGroup_2()); }
(rule__ArrayConcatenationOperator__Group_2__0)*
{ after(grammarAccess.getArrayConcatenationOperatorAccess().getGroup_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayConcatenationOperator__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConcatenationOperator__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConcatenationOperator__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConcatenationOperatorAccess().getRightSquareBracketKeyword_3()); }

	']' 

{ after(grammarAccess.getArrayConcatenationOperatorAccess().getRightSquareBracketKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__ArrayConcatenationOperator__Group_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConcatenationOperator__Group_2__0__Impl
	rule__ArrayConcatenationOperator__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConcatenationOperator__Group_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConcatenationOperatorAccess().getSemicolonKeyword_2_0()); }

	';' 

{ after(grammarAccess.getArrayConcatenationOperatorAccess().getSemicolonKeyword_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayConcatenationOperator__Group_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ArrayConcatenationOperator__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConcatenationOperator__Group_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConcatenationOperatorAccess().getRowsAssignment_2_1()); }
(rule__ArrayConcatenationOperator__RowsAssignment_2_1)
{ after(grammarAccess.getArrayConcatenationOperatorAccess().getRowsAssignment_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ExpressionList__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExpressionList__Group__0__Impl
	rule__ExpressionList__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExpressionList__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExpressionListAccess().getExpressionsAssignment_0()); }
(rule__ExpressionList__ExpressionsAssignment_0)
{ after(grammarAccess.getExpressionListAccess().getExpressionsAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExpressionList__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExpressionList__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExpressionList__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExpressionListAccess().getGroup_1()); }
(rule__ExpressionList__Group_1__0)*
{ after(grammarAccess.getExpressionListAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ExpressionList__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExpressionList__Group_1__0__Impl
	rule__ExpressionList__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExpressionList__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExpressionListAccess().getCommaKeyword_1_0()); }

	',' 

{ after(grammarAccess.getExpressionListAccess().getCommaKeyword_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExpressionList__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExpressionList__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExpressionList__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExpressionListAccess().getExpressionsAssignment_1_1()); }
(rule__ExpressionList__ExpressionsAssignment_1_1)
{ after(grammarAccess.getExpressionListAccess().getExpressionsAssignment_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__UnitConstructionOperator__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitConstructionOperator__Group__0__Impl
	rule__UnitConstructionOperator__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitConstructionOperator__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitConstructionOperatorAccess().getDollarSignKeyword_0()); }

	'$' 

{ after(grammarAccess.getUnitConstructionOperatorAccess().getDollarSignKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UnitConstructionOperator__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitConstructionOperator__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitConstructionOperator__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitConstructionOperatorAccess().getUnitAssignment_1()); }
(rule__UnitConstructionOperator__UnitAssignment_1)
{ after(grammarAccess.getUnitConstructionOperatorAccess().getUnitAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ParenthesizedExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ParenthesizedExpression__Group__0__Impl
	rule__ParenthesizedExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ParenthesizedExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); }

	'(' 

{ after(grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ParenthesizedExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ParenthesizedExpression__Group__1__Impl
	rule__ParenthesizedExpression__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ParenthesizedExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getParenthesizedExpressionAccess().getExpressionsAssignment_1()); }
(rule__ParenthesizedExpression__ExpressionsAssignment_1)
{ after(grammarAccess.getParenthesizedExpressionAccess().getExpressionsAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ParenthesizedExpression__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ParenthesizedExpression__Group__2__Impl
	rule__ParenthesizedExpression__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ParenthesizedExpression__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getParenthesizedExpressionAccess().getGroup_2()); }
(rule__ParenthesizedExpression__Group_2__0)*
{ after(grammarAccess.getParenthesizedExpressionAccess().getGroup_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ParenthesizedExpression__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ParenthesizedExpression__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ParenthesizedExpression__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_3()); }

	')' 

{ after(grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__ParenthesizedExpression__Group_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ParenthesizedExpression__Group_2__0__Impl
	rule__ParenthesizedExpression__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ParenthesizedExpression__Group_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getParenthesizedExpressionAccess().getCommaKeyword_2_0()); }

	',' 

{ after(grammarAccess.getParenthesizedExpressionAccess().getCommaKeyword_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ParenthesizedExpression__Group_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ParenthesizedExpression__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ParenthesizedExpression__Group_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getParenthesizedExpressionAccess().getExpressionsAssignment_2_1()); }
(rule__ParenthesizedExpression__ExpressionsAssignment_2_1)
{ after(grammarAccess.getParenthesizedExpressionAccess().getExpressionsAssignment_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__EndExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EndExpression__Group__0__Impl
	rule__EndExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EndExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEndExpressionAccess().getEndExpressionAction_0()); }
(

)
{ after(grammarAccess.getEndExpressionAccess().getEndExpressionAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EndExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EndExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EndExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEndExpressionAccess().getEndKeyword_1()); }

	'end' 

{ after(grammarAccess.getEndExpressionAccess().getEndKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__AlgorithmExpression__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AlgorithmExpression__Group__0__Impl
	rule__AlgorithmExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AlgorithmExpression__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAlgorithmExpressionAccess().getAlgorithmExpressionAction_0()); }
(

)
{ after(grammarAccess.getAlgorithmExpressionAccess().getAlgorithmExpressionAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AlgorithmExpression__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AlgorithmExpression__Group__1__Impl
	rule__AlgorithmExpression__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AlgorithmExpression__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAlgorithmExpressionAccess().getAlgoKeyword_1()); }

	'algo' 

{ after(grammarAccess.getAlgorithmExpressionAccess().getAlgoKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AlgorithmExpression__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AlgorithmExpression__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AlgorithmExpression__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAlgorithmExpressionAccess().getBodyAssignment_2()); }
(rule__AlgorithmExpression__BodyAssignment_2)
{ after(grammarAccess.getAlgorithmExpressionAccess().getBodyAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__Compound__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Compound__Group__0__Impl
	rule__Compound__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Compound__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundAccess().getCompoundAction_0()); }
(

)
{ after(grammarAccess.getCompoundAccess().getCompoundAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Compound__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Compound__Group__1__Impl
	rule__Compound__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Compound__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundAccess().getLeftCurlyBracketKeyword_1()); }

	'{' 

{ after(grammarAccess.getCompoundAccess().getLeftCurlyBracketKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Compound__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Compound__Group__2__Impl
	rule__Compound__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Compound__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundAccess().getStatementsAssignment_2()); }
(rule__Compound__StatementsAssignment_2)*
{ after(grammarAccess.getCompoundAccess().getStatementsAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Compound__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Compound__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Compound__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundAccess().getRightCurlyBracketKeyword_3()); }

	'}' 

{ after(grammarAccess.getCompoundAccess().getRightCurlyBracketKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__Assignment__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Assignment__Group__0__Impl
	rule__Assignment__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Assignment__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssignmentAccess().getTargetAssignment_0()); }
(rule__Assignment__TargetAssignment_0)
{ after(grammarAccess.getAssignmentAccess().getTargetAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Assignment__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Assignment__Group__1__Impl
	rule__Assignment__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Assignment__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssignmentAccess().getEqualsSignKeyword_1()); }

	'=' 

{ after(grammarAccess.getAssignmentAccess().getEqualsSignKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Assignment__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Assignment__Group__2__Impl
	rule__Assignment__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Assignment__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssignmentAccess().getExpressionAssignment_2()); }
(rule__Assignment__ExpressionAssignment_2)
{ after(grammarAccess.getAssignmentAccess().getExpressionAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Assignment__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Assignment__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Assignment__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssignmentAccess().getSemicolonKeyword_3()); }

	';' 

{ after(grammarAccess.getAssignmentAccess().getSemicolonKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__VariableDeclaration__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VariableDeclaration__Group__0__Impl
	rule__VariableDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableDeclaration__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableDeclarationAccess().getVarKeyword_0()); }

	'var' 

{ after(grammarAccess.getVariableDeclarationAccess().getVarKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__VariableDeclaration__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VariableDeclaration__Group__1__Impl
	rule__VariableDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableDeclaration__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableDeclarationAccess().getNameAssignment_1()); }
(rule__VariableDeclaration__NameAssignment_1)
{ after(grammarAccess.getVariableDeclarationAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__VariableDeclaration__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VariableDeclaration__Group__2__Impl
	rule__VariableDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableDeclaration__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableDeclarationAccess().getEqualsSignKeyword_2()); }

	'=' 

{ after(grammarAccess.getVariableDeclarationAccess().getEqualsSignKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__VariableDeclaration__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VariableDeclaration__Group__3__Impl
	rule__VariableDeclaration__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableDeclaration__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableDeclarationAccess().getInitializerAssignment_3()); }
(rule__VariableDeclaration__InitializerAssignment_3)
{ after(grammarAccess.getVariableDeclarationAccess().getInitializerAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__VariableDeclaration__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VariableDeclaration__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableDeclaration__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableDeclarationAccess().getSemicolonKeyword_4()); }

	';' 

{ after(grammarAccess.getVariableDeclarationAccess().getSemicolonKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__IfStatement__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfStatement__Group__0__Impl
	rule__IfStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IfStatement__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfStatementAccess().getIfKeyword_0()); }

	'if' 

{ after(grammarAccess.getIfStatementAccess().getIfKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IfStatement__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfStatement__Group__1__Impl
	rule__IfStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__IfStatement__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfStatementAccess().getLeftParenthesisKeyword_1()); }

	'(' 

{ after(grammarAccess.getIfStatementAccess().getLeftParenthesisKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IfStatement__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfStatement__Group__2__Impl
	rule__IfStatement__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__IfStatement__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfStatementAccess().getConditionAssignment_2()); }
(rule__IfStatement__ConditionAssignment_2)
{ after(grammarAccess.getIfStatementAccess().getConditionAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IfStatement__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfStatement__Group__3__Impl
	rule__IfStatement__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__IfStatement__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfStatementAccess().getRightParenthesisKeyword_3()); }

	')' 

{ after(grammarAccess.getIfStatementAccess().getRightParenthesisKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IfStatement__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfStatement__Group__4__Impl
	rule__IfStatement__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__IfStatement__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfStatementAccess().getThenStatementAssignment_4()); }
(rule__IfStatement__ThenStatementAssignment_4)
{ after(grammarAccess.getIfStatementAccess().getThenStatementAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IfStatement__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfStatement__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IfStatement__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfStatementAccess().getGroup_5()); }
(rule__IfStatement__Group_5__0)?
{ after(grammarAccess.getIfStatementAccess().getGroup_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}














rule__IfStatement__Group_5__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfStatement__Group_5__0__Impl
	rule__IfStatement__Group_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IfStatement__Group_5__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfStatementAccess().getElseKeyword_5_0()); }
(
	'else' 
)
{ after(grammarAccess.getIfStatementAccess().getElseKeyword_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IfStatement__Group_5__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IfStatement__Group_5__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IfStatement__Group_5__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfStatementAccess().getElseStatementAssignment_5_1()); }
(rule__IfStatement__ElseStatementAssignment_5_1)
{ after(grammarAccess.getIfStatementAccess().getElseStatementAssignment_5_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__WhileStatement__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__WhileStatement__Group__0__Impl
	rule__WhileStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getWhileStatementAccess().getWhileKeyword_0()); }

	'while' 

{ after(grammarAccess.getWhileStatementAccess().getWhileKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__WhileStatement__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__WhileStatement__Group__1__Impl
	rule__WhileStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getWhileStatementAccess().getLeftParenthesisKeyword_1()); }

	'(' 

{ after(grammarAccess.getWhileStatementAccess().getLeftParenthesisKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__WhileStatement__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__WhileStatement__Group__2__Impl
	rule__WhileStatement__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getWhileStatementAccess().getConditionAssignment_2()); }
(rule__WhileStatement__ConditionAssignment_2)
{ after(grammarAccess.getWhileStatementAccess().getConditionAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__WhileStatement__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__WhileStatement__Group__3__Impl
	rule__WhileStatement__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getWhileStatementAccess().getRightParenthesisKeyword_3()); }

	')' 

{ after(grammarAccess.getWhileStatementAccess().getRightParenthesisKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__WhileStatement__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__WhileStatement__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getWhileStatementAccess().getBodyAssignment_4()); }
(rule__WhileStatement__BodyAssignment_4)
{ after(grammarAccess.getWhileStatementAccess().getBodyAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__ForStatement__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ForStatement__Group__0__Impl
	rule__ForStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ForStatement__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getForStatementAccess().getForKeyword_0()); }

	'for' 

{ after(grammarAccess.getForStatementAccess().getForKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ForStatement__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ForStatement__Group__1__Impl
	rule__ForStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ForStatement__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getForStatementAccess().getLeftParenthesisKeyword_1()); }

	'(' 

{ after(grammarAccess.getForStatementAccess().getLeftParenthesisKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ForStatement__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ForStatement__Group__2__Impl
	rule__ForStatement__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ForStatement__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getForStatementAccess().getIterationVariableAssignment_2()); }
(rule__ForStatement__IterationVariableAssignment_2)
{ after(grammarAccess.getForStatementAccess().getIterationVariableAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ForStatement__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ForStatement__Group__3__Impl
	rule__ForStatement__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ForStatement__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getForStatementAccess().getInKeyword_3()); }

	'in' 

{ after(grammarAccess.getForStatementAccess().getInKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ForStatement__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ForStatement__Group__4__Impl
	rule__ForStatement__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ForStatement__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getForStatementAccess().getCollectionExpressionAssignment_4()); }
(rule__ForStatement__CollectionExpressionAssignment_4)
{ after(grammarAccess.getForStatementAccess().getCollectionExpressionAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ForStatement__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ForStatement__Group__5__Impl
	rule__ForStatement__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__ForStatement__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_5()); }

	')' 

{ after(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ForStatement__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ForStatement__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ForStatement__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getForStatementAccess().getBodyAssignment_6()); }
(rule__ForStatement__BodyAssignment_6)
{ after(grammarAccess.getForStatementAccess().getBodyAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__DoWhileStatement__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DoWhileStatement__Group__0__Impl
	rule__DoWhileStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DoWhileStatement__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDoWhileStatementAccess().getDoKeyword_0()); }

	'do' 

{ after(grammarAccess.getDoWhileStatementAccess().getDoKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DoWhileStatement__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DoWhileStatement__Group__1__Impl
	rule__DoWhileStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__DoWhileStatement__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDoWhileStatementAccess().getBodyAssignment_1()); }
(rule__DoWhileStatement__BodyAssignment_1)
{ after(grammarAccess.getDoWhileStatementAccess().getBodyAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DoWhileStatement__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DoWhileStatement__Group__2__Impl
	rule__DoWhileStatement__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__DoWhileStatement__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDoWhileStatementAccess().getWhileKeyword_2()); }

	'while' 

{ after(grammarAccess.getDoWhileStatementAccess().getWhileKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DoWhileStatement__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DoWhileStatement__Group__3__Impl
	rule__DoWhileStatement__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__DoWhileStatement__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDoWhileStatementAccess().getLeftParenthesisKeyword_3()); }

	'(' 

{ after(grammarAccess.getDoWhileStatementAccess().getLeftParenthesisKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DoWhileStatement__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DoWhileStatement__Group__4__Impl
	rule__DoWhileStatement__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__DoWhileStatement__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDoWhileStatementAccess().getConditionAssignment_4()); }
(rule__DoWhileStatement__ConditionAssignment_4)
{ after(grammarAccess.getDoWhileStatementAccess().getConditionAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DoWhileStatement__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DoWhileStatement__Group__5__Impl
	rule__DoWhileStatement__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__DoWhileStatement__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDoWhileStatementAccess().getRightParenthesisKeyword_5()); }

	')' 

{ after(grammarAccess.getDoWhileStatementAccess().getRightParenthesisKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DoWhileStatement__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DoWhileStatement__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DoWhileStatement__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDoWhileStatementAccess().getSemicolonKeyword_6()); }

	';' 

{ after(grammarAccess.getDoWhileStatementAccess().getSemicolonKeyword_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__ContinueStatement__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinueStatement__Group__0__Impl
	rule__ContinueStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinueStatement__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinueStatementAccess().getContinueStatementAction_0()); }
(

)
{ after(grammarAccess.getContinueStatementAccess().getContinueStatementAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ContinueStatement__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinueStatement__Group__1__Impl
	rule__ContinueStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinueStatement__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinueStatementAccess().getContinueKeyword_1()); }

	'continue' 

{ after(grammarAccess.getContinueStatementAccess().getContinueKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ContinueStatement__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinueStatement__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinueStatement__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinueStatementAccess().getSemicolonKeyword_2()); }

	';' 

{ after(grammarAccess.getContinueStatementAccess().getSemicolonKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__BreakStatement__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BreakStatement__Group__0__Impl
	rule__BreakStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BreakStatement__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBreakStatementAccess().getBreakStatementAction_0()); }
(

)
{ after(grammarAccess.getBreakStatementAccess().getBreakStatementAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__BreakStatement__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BreakStatement__Group__1__Impl
	rule__BreakStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__BreakStatement__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBreakStatementAccess().getBreakKeyword_1()); }

	'break' 

{ after(grammarAccess.getBreakStatementAccess().getBreakKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__BreakStatement__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BreakStatement__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BreakStatement__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBreakStatementAccess().getSemicolonKeyword_2()); }

	';' 

{ after(grammarAccess.getBreakStatementAccess().getSemicolonKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__ReturnStatement__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ReturnStatement__Group__0__Impl
	rule__ReturnStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ReturnStatement__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getReturnStatementAccess().getReturnKeyword_0()); }

	'return' 

{ after(grammarAccess.getReturnStatementAccess().getReturnKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ReturnStatement__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ReturnStatement__Group__1__Impl
	rule__ReturnStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ReturnStatement__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getReturnStatementAccess().getExpressionAssignment_1()); }
(rule__ReturnStatement__ExpressionAssignment_1)
{ after(grammarAccess.getReturnStatementAccess().getExpressionAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ReturnStatement__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ReturnStatement__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ReturnStatement__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getReturnStatementAccess().getSemicolonKeyword_2()); }

	';' 

{ after(grammarAccess.getReturnStatementAccess().getSemicolonKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__Unit__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Unit__Group__0__Impl
	rule__Unit__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getUnitAction_0()); }
(

)
{ after(grammarAccess.getUnitAccess().getUnitAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Unit__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Unit__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getAlternatives_1()); }
(rule__Unit__Alternatives_1)
{ after(grammarAccess.getUnitAccess().getAlternatives_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Unit__Group_1_0__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Unit__Group_1_0__0__Impl
	rule__Unit__Group_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__Group_1_0__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getLeftParenthesisKeyword_1_0_0()); }

	'(' 

{ after(grammarAccess.getUnitAccess().getLeftParenthesisKeyword_1_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Unit__Group_1_0__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Unit__Group_1_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__Group_1_0__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getRightParenthesisKeyword_1_0_1()); }

	')' 

{ after(grammarAccess.getUnitAccess().getRightParenthesisKeyword_1_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Unit__Group_1_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Unit__Group_1_1__0__Impl
	rule__Unit__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__Group_1_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getLeftParenthesisKeyword_1_1_0()); }

	'(' 

{ after(grammarAccess.getUnitAccess().getLeftParenthesisKeyword_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Unit__Group_1_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Unit__Group_1_1__1__Impl
	rule__Unit__Group_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__Group_1_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getNumeratorAssignment_1_1_1()); }
(rule__Unit__NumeratorAssignment_1_1_1)
{ after(grammarAccess.getUnitAccess().getNumeratorAssignment_1_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Unit__Group_1_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Unit__Group_1_1__2__Impl
	rule__Unit__Group_1_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__Group_1_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getGroup_1_1_2()); }
(rule__Unit__Group_1_1_2__0)?
{ after(grammarAccess.getUnitAccess().getGroup_1_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Unit__Group_1_1__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Unit__Group_1_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__Group_1_1__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getRightParenthesisKeyword_1_1_3()); }

	')' 

{ after(grammarAccess.getUnitAccess().getRightParenthesisKeyword_1_1_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__Unit__Group_1_1_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Unit__Group_1_1_2__0__Impl
	rule__Unit__Group_1_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__Group_1_1_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getSolidusKeyword_1_1_2_0()); }

	'/' 

{ after(grammarAccess.getUnitAccess().getSolidusKeyword_1_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Unit__Group_1_1_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Unit__Group_1_1_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__Group_1_1_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getDenominatorAssignment_1_1_2_1()); }
(rule__Unit__DenominatorAssignment_1_1_2_1)
{ after(grammarAccess.getUnitAccess().getDenominatorAssignment_1_1_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ExplicitUnit__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExplicitUnit__Group__0__Impl
	rule__ExplicitUnit__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExplicitUnit__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExplicitUnitAccess().getLeftParenthesisKeyword_0()); }

	'(' 

{ after(grammarAccess.getExplicitUnitAccess().getLeftParenthesisKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExplicitUnit__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExplicitUnit__Group__1__Impl
	rule__ExplicitUnit__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExplicitUnit__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExplicitUnitAccess().getNumeratorAssignment_1()); }
(rule__ExplicitUnit__NumeratorAssignment_1)
{ after(grammarAccess.getExplicitUnitAccess().getNumeratorAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExplicitUnit__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExplicitUnit__Group__2__Impl
	rule__ExplicitUnit__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ExplicitUnit__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExplicitUnitAccess().getGroup_2()); }
(rule__ExplicitUnit__Group_2__0)?
{ after(grammarAccess.getExplicitUnitAccess().getGroup_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExplicitUnit__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExplicitUnit__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExplicitUnit__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExplicitUnitAccess().getRightParenthesisKeyword_3()); }

	')' 

{ after(grammarAccess.getExplicitUnitAccess().getRightParenthesisKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__ExplicitUnit__Group_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExplicitUnit__Group_2__0__Impl
	rule__ExplicitUnit__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExplicitUnit__Group_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExplicitUnitAccess().getSolidusKeyword_2_0()); }

	'/' 

{ after(grammarAccess.getExplicitUnitAccess().getSolidusKeyword_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExplicitUnit__Group_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExplicitUnit__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExplicitUnit__Group_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExplicitUnitAccess().getDenominatorAssignment_2_1()); }
(rule__ExplicitUnit__DenominatorAssignment_2_1)
{ after(grammarAccess.getExplicitUnitAccess().getDenominatorAssignment_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__UnitNumerator__Group_0__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitNumerator__Group_0__0__Impl
	rule__UnitNumerator__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitNumerator__Group_0__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitNumeratorAccess().getUnitNumeratorAction_0_0()); }
(

)
{ after(grammarAccess.getUnitNumeratorAccess().getUnitNumeratorAction_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UnitNumerator__Group_0__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitNumerator__Group_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitNumerator__Group_0__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitNumeratorAccess().getONETerminalRuleCall_0_1()); }
	RULE_ONE
{ after(grammarAccess.getUnitNumeratorAccess().getONETerminalRuleCall_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__UnitNumerator__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitNumerator__Group_1__0__Impl
	rule__UnitNumerator__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitNumerator__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitNumeratorAccess().getFactorsAssignment_1_0()); }
(rule__UnitNumerator__FactorsAssignment_1_0)
{ after(grammarAccess.getUnitNumeratorAccess().getFactorsAssignment_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UnitNumerator__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitNumerator__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitNumerator__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitNumeratorAccess().getGroup_1_1()); }
(rule__UnitNumerator__Group_1_1__0)*
{ after(grammarAccess.getUnitNumeratorAccess().getGroup_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__UnitNumerator__Group_1_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitNumerator__Group_1_1__0__Impl
	rule__UnitNumerator__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitNumerator__Group_1_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitNumeratorAccess().getAsteriskKeyword_1_1_0()); }

	'*' 

{ after(grammarAccess.getUnitNumeratorAccess().getAsteriskKeyword_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UnitNumerator__Group_1_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitNumerator__Group_1_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitNumerator__Group_1_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitNumeratorAccess().getFactorsAssignment_1_1_1()); }
(rule__UnitNumerator__FactorsAssignment_1_1_1)
{ after(grammarAccess.getUnitNumeratorAccess().getFactorsAssignment_1_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__UnitDenominator__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitDenominator__Group_1__0__Impl
	rule__UnitDenominator__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitDenominator__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitDenominatorAccess().getLeftParenthesisKeyword_1_0()); }

	'(' 

{ after(grammarAccess.getUnitDenominatorAccess().getLeftParenthesisKeyword_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UnitDenominator__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitDenominator__Group_1__1__Impl
	rule__UnitDenominator__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitDenominator__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitDenominatorAccess().getFactorsAssignment_1_1()); }
(rule__UnitDenominator__FactorsAssignment_1_1)
{ after(grammarAccess.getUnitDenominatorAccess().getFactorsAssignment_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UnitDenominator__Group_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitDenominator__Group_1__2__Impl
	rule__UnitDenominator__Group_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitDenominator__Group_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitDenominatorAccess().getGroup_1_2()); }
(rule__UnitDenominator__Group_1_2__0)*
{ after(grammarAccess.getUnitDenominatorAccess().getGroup_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UnitDenominator__Group_1__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitDenominator__Group_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitDenominator__Group_1__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitDenominatorAccess().getRightParenthesisKeyword_1_3()); }

	')' 

{ after(grammarAccess.getUnitDenominatorAccess().getRightParenthesisKeyword_1_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__UnitDenominator__Group_1_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitDenominator__Group_1_2__0__Impl
	rule__UnitDenominator__Group_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitDenominator__Group_1_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitDenominatorAccess().getAsteriskKeyword_1_2_0()); }

	'*' 

{ after(grammarAccess.getUnitDenominatorAccess().getAsteriskKeyword_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UnitDenominator__Group_1_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitDenominator__Group_1_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitDenominator__Group_1_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitDenominatorAccess().getFactorsAssignment_1_2_1()); }
(rule__UnitDenominator__FactorsAssignment_1_2_1)
{ after(grammarAccess.getUnitDenominatorAccess().getFactorsAssignment_1_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__UnitFactor__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitFactor__Group__0__Impl
	rule__UnitFactor__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitFactor__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitFactorAccess().getSymbolAssignment_0()); }
(rule__UnitFactor__SymbolAssignment_0)
{ after(grammarAccess.getUnitFactorAccess().getSymbolAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UnitFactor__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitFactor__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitFactor__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitFactorAccess().getGroup_1()); }
(rule__UnitFactor__Group_1__0)?
{ after(grammarAccess.getUnitFactorAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__UnitFactor__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitFactor__Group_1__0__Impl
	rule__UnitFactor__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitFactor__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitFactorAccess().getCircumflexAccentKeyword_1_0()); }

	'^' 

{ after(grammarAccess.getUnitFactorAccess().getCircumflexAccentKeyword_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UnitFactor__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitFactor__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitFactor__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitFactorAccess().getExponentAssignment_1_1()); }
(rule__UnitFactor__ExponentAssignment_1_1)
{ after(grammarAccess.getUnitFactorAccess().getExponentAssignment_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__UnitExponent__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitExponent__Group__0__Impl
	rule__UnitExponent__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitExponent__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitExponentAccess().getHyphenMinusKeyword_0()); }
(
	'-' 
)?
{ after(grammarAccess.getUnitExponentAccess().getHyphenMinusKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UnitExponent__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UnitExponent__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnitExponent__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitExponentAccess().getValidIntParserRuleCall_1()); }
	ruleValidInt
{ after(grammarAccess.getUnitExponentAccess().getValidIntParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






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

rule__QualifiedName__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); }
	ruleValidID
{ after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


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

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

;
finally {
	restoreStackSize(stackSize);
}






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

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

	'::' 

{ after(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


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

rule__QualifiedName__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); }
	ruleValidID
{ after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}







rule__Module__DefinitionsAssignment
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getModuleAccess().getDefinitionsDefinitionParserRuleCall_0()); }
	ruleDefinition{ after(grammarAccess.getModuleAccess().getDefinitionsDefinitionParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationDefinition__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationDefinitionAccess().getNameValidIDParserRuleCall_1_0()); }
	ruleValidID{ after(grammarAccess.getEnumerationDefinitionAccess().getNameValidIDParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationDefinition__LiteralDeclarationsAssignment_3_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationDefinitionAccess().getLiteralDeclarationsEnumerationLiteralDeclarationParserRuleCall_3_0_0()); }
	ruleEnumerationLiteralDeclaration{ after(grammarAccess.getEnumerationDefinitionAccess().getLiteralDeclarationsEnumerationLiteralDeclarationParserRuleCall_3_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationDefinition__LiteralDeclarationsAssignment_3_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationDefinitionAccess().getLiteralDeclarationsEnumerationLiteralDeclarationParserRuleCall_3_1_1_0()); }
	ruleEnumerationLiteralDeclaration{ after(grammarAccess.getEnumerationDefinitionAccess().getLiteralDeclarationsEnumerationLiteralDeclarationParserRuleCall_3_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationLiteralDeclaration__NameAssignment
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationLiteralDeclarationAccess().getNameValidIDParserRuleCall_0()); }
	ruleValidID{ after(grammarAccess.getEnumerationLiteralDeclarationAccess().getNameValidIDParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TypeAliasDefinition__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTypeAliasDefinitionAccess().getNameValidIDParserRuleCall_1_0()); }
	ruleValidID{ after(grammarAccess.getTypeAliasDefinitionAccess().getNameValidIDParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TypeAliasDefinition__TypeAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTypeAliasDefinitionAccess().getTypePrimitiveTypeParserRuleCall_3_0()); }
	rulePrimitiveType{ after(grammarAccess.getTypeAliasDefinitionAccess().getTypePrimitiveTypeParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RecordDefinition__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRecordDefinitionAccess().getNameValidIDParserRuleCall_1_0()); }
	ruleValidID{ after(grammarAccess.getRecordDefinitionAccess().getNameValidIDParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RecordDefinition__FieldDeclarationsAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRecordDefinitionAccess().getFieldDeclarationsRecordFieldDeclarationParserRuleCall_3_0()); }
	ruleRecordFieldDeclaration{ after(grammarAccess.getRecordDefinitionAccess().getFieldDeclarationsRecordFieldDeclarationParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFieldDeclaration__NameAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRecordFieldDeclarationAccess().getNameValidIDParserRuleCall_0_0()); }
	ruleValidID{ after(grammarAccess.getRecordFieldDeclarationAccess().getNameValidIDParserRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFieldDeclaration__TypeAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRecordFieldDeclarationAccess().getTypeDataTypeSpecifierParserRuleCall_2_0()); }
	ruleDataTypeSpecifier{ after(grammarAccess.getRecordFieldDeclarationAccess().getTypeDataTypeSpecifierParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__KindAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getKindFunctionKindEnumRuleCall_0_0()); }
	ruleFunctionKind{ after(grammarAccess.getFunctionDefinitionAccess().getKindFunctionKindEnumRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__NameAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getNameValidIDParserRuleCall_2_0()); }
	ruleValidID{ after(grammarAccess.getFunctionDefinitionAccess().getNameValidIDParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__TemplateParameterDeclarationsAssignment_3_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getTemplateParameterDeclarationsTemplateParameterDeclarationParserRuleCall_3_1_0()); }
	ruleTemplateParameterDeclaration{ after(grammarAccess.getFunctionDefinitionAccess().getTemplateParameterDeclarationsTemplateParameterDeclarationParserRuleCall_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__TemplateParameterDeclarationsAssignment_3_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getTemplateParameterDeclarationsTemplateParameterDeclarationParserRuleCall_3_2_1_0()); }
	ruleTemplateParameterDeclaration{ after(grammarAccess.getFunctionDefinitionAccess().getTemplateParameterDeclarationsTemplateParameterDeclarationParserRuleCall_3_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__InputParameterDeclarationsAssignment_5_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getInputParameterDeclarationsInputParameterDeclarationParserRuleCall_5_0_0()); }
	ruleInputParameterDeclaration{ after(grammarAccess.getFunctionDefinitionAccess().getInputParameterDeclarationsInputParameterDeclarationParserRuleCall_5_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__InputParameterDeclarationsAssignment_5_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getInputParameterDeclarationsInputParameterDeclarationParserRuleCall_5_1_1_0()); }
	ruleInputParameterDeclaration{ after(grammarAccess.getFunctionDefinitionAccess().getInputParameterDeclarationsInputParameterDeclarationParserRuleCall_5_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__OutputParameterDeclarationsAssignment_8
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getOutputParameterDeclarationsOutputParameterDeclarationParserRuleCall_8_0()); }
	ruleOutputParameterDeclaration{ after(grammarAccess.getFunctionDefinitionAccess().getOutputParameterDeclarationsOutputParameterDeclarationParserRuleCall_8_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__OutputParameterDeclarationsAssignment_9_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getOutputParameterDeclarationsOutputParameterDeclarationParserRuleCall_9_1_0()); }
	ruleOutputParameterDeclaration{ after(grammarAccess.getFunctionDefinitionAccess().getOutputParameterDeclarationsOutputParameterDeclarationParserRuleCall_9_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__ChecksAssignment_11_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getChecksCheckParserRuleCall_11_0_0()); }
	ruleCheck{ after(grammarAccess.getFunctionDefinitionAccess().getChecksCheckParserRuleCall_11_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__AssertionsAssignment_11_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getAssertionsAssertionParserRuleCall_11_1_0()); }
	ruleAssertion{ after(grammarAccess.getFunctionDefinitionAccess().getAssertionsAssertionParserRuleCall_11_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__FunctionObjectDeclarationsAssignment_11_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getFunctionObjectDeclarationsFunctionObjectDeclarationParserRuleCall_11_2_0()); }
	ruleFunctionObjectDeclaration{ after(grammarAccess.getFunctionDefinitionAccess().getFunctionObjectDeclarationsFunctionObjectDeclarationParserRuleCall_11_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__StateVariableDeclarationsAssignment_11_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getStateVariableDeclarationsStateVariableDeclarationParserRuleCall_11_3_0()); }
	ruleStateVariableDeclaration{ after(grammarAccess.getFunctionDefinitionAccess().getStateVariableDeclarationsStateVariableDeclarationParserRuleCall_11_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__EquationsAssignment_11_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionDefinitionAccess().getEquationsEquationParserRuleCall_11_4_0()); }
	ruleEquation{ after(grammarAccess.getFunctionDefinitionAccess().getEquationsEquationParserRuleCall_11_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TemplateParameterDeclaration__NameAssignment
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTemplateParameterDeclarationAccess().getNameValidIDParserRuleCall_0()); }
	ruleValidID{ after(grammarAccess.getTemplateParameterDeclarationAccess().getNameValidIDParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__InputParameterDeclaration__NameAssignment
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInputParameterDeclarationAccess().getNameValidIDParserRuleCall_0()); }
	ruleValidID{ after(grammarAccess.getInputParameterDeclarationAccess().getNameValidIDParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__OutputParameterDeclaration__NameAssignment
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutputParameterDeclarationAccess().getNameValidIDParserRuleCall_0()); }
	ruleValidID{ after(grammarAccess.getOutputParameterDeclarationAccess().getNameValidIDParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Check__TemplateArgumentsAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getTemplateArgumentsExpressionParserRuleCall_1_1_0()); }
	ruleExpression{ after(grammarAccess.getCheckAccess().getTemplateArgumentsExpressionParserRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Check__TemplateArgumentsAssignment_1_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getTemplateArgumentsExpressionParserRuleCall_1_2_1_0()); }
	ruleExpression{ after(grammarAccess.getCheckAccess().getTemplateArgumentsExpressionParserRuleCall_1_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Check__InputParameterTypesAssignment_3_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getInputParameterTypesDataTypeSpecifierParserRuleCall_3_0_0()); }
	ruleDataTypeSpecifier{ after(grammarAccess.getCheckAccess().getInputParameterTypesDataTypeSpecifierParserRuleCall_3_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Check__InputParameterTypesAssignment_3_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getInputParameterTypesDataTypeSpecifierParserRuleCall_3_1_1_0()); }
	ruleDataTypeSpecifier{ after(grammarAccess.getCheckAccess().getInputParameterTypesDataTypeSpecifierParserRuleCall_3_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Check__OutputParameterTypesAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getOutputParameterTypesDataTypeSpecifierParserRuleCall_6_0()); }
	ruleDataTypeSpecifier{ after(grammarAccess.getCheckAccess().getOutputParameterTypesDataTypeSpecifierParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Check__OutputParameterTypesAssignment_7_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCheckAccess().getOutputParameterTypesDataTypeSpecifierParserRuleCall_7_1_0()); }
	ruleDataTypeSpecifier{ after(grammarAccess.getCheckAccess().getOutputParameterTypesDataTypeSpecifierParserRuleCall_7_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Assertion__StaticAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssertionAccess().getStaticStaticKeyword_0_0()); }
(
{ before(grammarAccess.getAssertionAccess().getStaticStaticKeyword_0_0()); }

	'static' 

{ after(grammarAccess.getAssertionAccess().getStaticStaticKeyword_0_0()); }
)

{ after(grammarAccess.getAssertionAccess().getStaticStaticKeyword_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Assertion__ConditionAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssertionAccess().getConditionExpressionParserRuleCall_2_0()); }
	ruleExpression{ after(grammarAccess.getAssertionAccess().getConditionExpressionParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Assertion__StatusKindAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssertionAccess().getStatusKindAssertionStatusKindEnumRuleCall_4_0()); }
	ruleAssertionStatusKind{ after(grammarAccess.getAssertionAccess().getStatusKindAssertionStatusKindEnumRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Assertion__MessageAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssertionAccess().getMessageExpressionParserRuleCall_5_0()); }
	ruleExpression{ after(grammarAccess.getAssertionAccess().getMessageExpressionParserRuleCall_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StateVariableDeclaration__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateVariableDeclarationAccess().getNameValidIDParserRuleCall_1_0()); }
	ruleValidID{ after(grammarAccess.getStateVariableDeclarationAccess().getNameValidIDParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getNameValidIDParserRuleCall_1_0()); }
	ruleValidID{ after(grammarAccess.getFunctionObjectDeclarationAccess().getNameValidIDParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__FunctionNameAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getFunctionNameFunctionDefinitionCrossReference_3_0()); }
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getFunctionNameFunctionDefinitionQualifiedNameParserRuleCall_3_0_1()); }
	ruleQualifiedName{ after(grammarAccess.getFunctionObjectDeclarationAccess().getFunctionNameFunctionDefinitionQualifiedNameParserRuleCall_3_0_1()); }
)
{ after(grammarAccess.getFunctionObjectDeclarationAccess().getFunctionNameFunctionDefinitionCrossReference_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__TemplateArgumentsAssignment_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getTemplateArgumentsExpressionParserRuleCall_4_1_0()); }
	ruleExpression{ after(grammarAccess.getFunctionObjectDeclarationAccess().getTemplateArgumentsExpressionParserRuleCall_4_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionObjectDeclaration__TemplateArgumentsAssignment_4_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionObjectDeclarationAccess().getTemplateArgumentsExpressionParserRuleCall_4_2_1_0()); }
	ruleExpression{ after(grammarAccess.getFunctionObjectDeclarationAccess().getTemplateArgumentsExpressionParserRuleCall_4_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Equation__InitialAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEquationAccess().getInitialInitialKeyword_0_0()); }
(
{ before(grammarAccess.getEquationAccess().getInitialInitialKeyword_0_0()); }

	'initial' 

{ after(grammarAccess.getEquationAccess().getInitialInitialKeyword_0_0()); }
)

{ after(grammarAccess.getEquationAccess().getInitialInitialKeyword_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Equation__LeftHandSideAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEquationAccess().getLeftHandSideExpressionParserRuleCall_1_0()); }
	ruleExpression{ after(grammarAccess.getEquationAccess().getLeftHandSideExpressionParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Equation__RightHandSideAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEquationAccess().getRightHandSideExpressionParserRuleCall_3_0()); }
	ruleExpression{ after(grammarAccess.getEquationAccess().getRightHandSideExpressionParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataTypeSpecifier__DefinedTypeAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataTypeSpecifierAccess().getDefinedTypeAlternatives_0_0()); }
(rule__DataTypeSpecifier__DefinedTypeAlternatives_0_0)
{ after(grammarAccess.getDataTypeSpecifierAccess().getDefinedTypeAlternatives_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataTypeSpecifier__TypeAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataTypeSpecifierAccess().getTypeDataTypeCrossReference_1_0()); }
(
{ before(grammarAccess.getDataTypeSpecifierAccess().getTypeDataTypeIDTerminalRuleCall_1_0_1()); }
	RULE_ID{ after(grammarAccess.getDataTypeSpecifierAccess().getTypeDataTypeIDTerminalRuleCall_1_0_1()); }
)
{ after(grammarAccess.getDataTypeSpecifierAccess().getTypeDataTypeCrossReference_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RealType__UnitAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealTypeAccess().getUnitUnitParserRuleCall_2_0()); }
	ruleUnit{ after(grammarAccess.getRealTypeAccess().getUnitUnitParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerType__UnitAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntegerTypeAccess().getUnitUnitParserRuleCall_2_0()); }
	ruleUnit{ after(grammarAccess.getIntegerTypeAccess().getUnitUnitParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ComplexType__UnitAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getComplexTypeAccess().getUnitUnitParserRuleCall_2_0()); }
	ruleUnit{ after(grammarAccess.getComplexTypeAccess().getUnitUnitParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__GaussianType__UnitAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGaussianTypeAccess().getUnitUnitParserRuleCall_2_0()); }
	ruleUnit{ after(grammarAccess.getGaussianTypeAccess().getUnitUnitParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__DefinedElementTypeAssignment_1_0_0_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getDefinedElementTypePrimitiveTypeParserRuleCall_1_0_0_0_0()); }
	rulePrimitiveType{ after(grammarAccess.getArrayTypeAccess().getDefinedElementTypePrimitiveTypeParserRuleCall_1_0_0_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__ElementTypeAssignment_1_0_0_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getElementTypeDataTypeCrossReference_1_0_0_1_0()); }
(
{ before(grammarAccess.getArrayTypeAccess().getElementTypeDataTypeIDTerminalRuleCall_1_0_0_1_0_1()); }
	RULE_ID{ after(grammarAccess.getArrayTypeAccess().getElementTypeDataTypeIDTerminalRuleCall_1_0_0_1_0_1()); }
)
{ after(grammarAccess.getArrayTypeAccess().getElementTypeDataTypeCrossReference_1_0_0_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__DimensionsAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getDimensionsArrayDimensionParserRuleCall_1_2_0()); }
	ruleArrayDimension{ after(grammarAccess.getArrayTypeAccess().getDimensionsArrayDimensionParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__DimensionsAssignment_1_3_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayTypeAccess().getDimensionsArrayDimensionParserRuleCall_1_3_1_0()); }
	ruleArrayDimension{ after(grammarAccess.getArrayTypeAccess().getDimensionsArrayDimensionParserRuleCall_1_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TensorType__DefinedElementTypeAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTensorTypeAccess().getDefinedElementTypeNumericTypeParserRuleCall_0_0()); }
	ruleNumericType{ after(grammarAccess.getTensorTypeAccess().getDefinedElementTypeNumericTypeParserRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TensorType__DimensionsAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTensorTypeAccess().getDimensionsArrayDimensionParserRuleCall_2_0()); }
	ruleArrayDimension{ after(grammarAccess.getTensorTypeAccess().getDimensionsArrayDimensionParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TensorType__DimensionsAssignment_3_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTensorTypeAccess().getDimensionsArrayDimensionParserRuleCall_3_1_0()); }
	ruleArrayDimension{ after(grammarAccess.getTensorTypeAccess().getDimensionsArrayDimensionParserRuleCall_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayDimension__SizeAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayDimensionAccess().getSizeExpressionParserRuleCall_1_0()); }
	ruleExpression{ after(grammarAccess.getArrayDimensionAccess().getSizeExpressionParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__VariableDeclarationsAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionAccess().getVariableDeclarationsLetExpressionVariableDeclarationParserRuleCall_1_0()); }
	ruleLetExpressionVariableDeclaration{ after(grammarAccess.getLetExpressionAccess().getVariableDeclarationsLetExpressionVariableDeclarationParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__VariableDeclarationsAssignment_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionAccess().getVariableDeclarationsLetExpressionVariableDeclarationParserRuleCall_2_1_0()); }
	ruleLetExpressionVariableDeclaration{ after(grammarAccess.getLetExpressionAccess().getVariableDeclarationsLetExpressionVariableDeclarationParserRuleCall_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__TargetExpressionAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionAccess().getTargetExpressionExpressionParserRuleCall_4_0()); }
	ruleExpression{ after(grammarAccess.getLetExpressionAccess().getTargetExpressionExpressionParserRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__PartsAssignment_0_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getPartsLetExpressionVariableDeclarationPartParserRuleCall_0_0_0()); }
	ruleLetExpressionVariableDeclarationPart{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getPartsLetExpressionVariableDeclarationPartParserRuleCall_0_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__PartsAssignment_0_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getPartsLetExpressionVariableDeclarationPartParserRuleCall_0_1_1_0()); }
	ruleLetExpressionVariableDeclarationPart{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getPartsLetExpressionVariableDeclarationPartParserRuleCall_0_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__PartsAssignment_0_1_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getPartsLetExpressionVariableDeclarationPartParserRuleCall_0_1_2_1_0()); }
	ruleLetExpressionVariableDeclarationPart{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getPartsLetExpressionVariableDeclarationPartParserRuleCall_0_1_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclaration__AssignedExpressionAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationAccess().getAssignedExpressionExpressionParserRuleCall_2_0()); }
	ruleExpression{ after(grammarAccess.getLetExpressionVariableDeclarationAccess().getAssignedExpressionExpressionParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpressionVariableDeclarationPart__NameAssignment
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLetExpressionVariableDeclarationPartAccess().getNameValidIDParserRuleCall_0()); }
	ruleValidID{ after(grammarAccess.getLetExpressionVariableDeclarationPartAccess().getNameValidIDParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IfExpression__StaticAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfExpressionAccess().getStaticStaticKeyword_0_0()); }
(
{ before(grammarAccess.getIfExpressionAccess().getStaticStaticKeyword_0_0()); }

	'static' 

{ after(grammarAccess.getIfExpressionAccess().getStaticStaticKeyword_0_0()); }
)

{ after(grammarAccess.getIfExpressionAccess().getStaticStaticKeyword_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IfExpression__ConditionAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfExpressionAccess().getConditionExpressionParserRuleCall_2_0()); }
	ruleExpression{ after(grammarAccess.getIfExpressionAccess().getConditionExpressionParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IfExpression__ThenExpressionAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfExpressionAccess().getThenExpressionExpressionParserRuleCall_4_0()); }
	ruleExpression{ after(grammarAccess.getIfExpressionAccess().getThenExpressionExpressionParserRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IfExpression__ElseExpressionAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfExpressionAccess().getElseExpressionExpressionParserRuleCall_6_0()); }
	ruleExpression{ after(grammarAccess.getIfExpressionAccess().getElseExpressionExpressionParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchExpression__StaticAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchExpressionAccess().getStaticStaticKeyword_0_0()); }
(
{ before(grammarAccess.getSwitchExpressionAccess().getStaticStaticKeyword_0_0()); }

	'static' 

{ after(grammarAccess.getSwitchExpressionAccess().getStaticStaticKeyword_0_0()); }
)

{ after(grammarAccess.getSwitchExpressionAccess().getStaticStaticKeyword_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchExpression__ControlExpressionAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchExpressionAccess().getControlExpressionExpressionParserRuleCall_2_0()); }
	ruleExpression{ after(grammarAccess.getSwitchExpressionAccess().getControlExpressionExpressionParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchExpression__CasesAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchExpressionAccess().getCasesSwitchCaseParserRuleCall_3_0()); }
	ruleSwitchCase{ after(grammarAccess.getSwitchExpressionAccess().getCasesSwitchCaseParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchExpression__DefaultExpressionAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchExpressionAccess().getDefaultExpressionExpressionParserRuleCall_6_0()); }
	ruleExpression{ after(grammarAccess.getSwitchExpressionAccess().getDefaultExpressionExpressionParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchCase__CaseExpressionAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchCaseAccess().getCaseExpressionImpliesExpressionParserRuleCall_1_0()); }
	ruleImpliesExpression{ after(grammarAccess.getSwitchCaseAccess().getCaseExpressionImpliesExpressionParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SwitchCase__ResultExpressionAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSwitchCaseAccess().getResultExpressionExpressionParserRuleCall_3_0()); }
	ruleExpression{ after(grammarAccess.getSwitchCaseAccess().getResultExpressionExpressionParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RangeExpression__OperandsAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeExpressionAccess().getOperandsImpliesExpressionParserRuleCall_1_2_0()); }
	ruleImpliesExpression{ after(grammarAccess.getRangeExpressionAccess().getOperandsImpliesExpressionParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RangeExpression__OperandsAssignment_1_3_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeExpressionAccess().getOperandsImpliesExpressionParserRuleCall_1_3_1_0()); }
	ruleImpliesExpression{ after(grammarAccess.getRangeExpressionAccess().getOperandsImpliesExpressionParserRuleCall_1_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ImpliesExpression__RightOperandAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImpliesExpressionAccess().getRightOperandLogicalOrExpressionParserRuleCall_1_2_0()); }
	ruleLogicalOrExpression{ after(grammarAccess.getImpliesExpressionAccess().getRightOperandLogicalOrExpressionParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalOrExpression__RightOperandAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalOrExpressionAccess().getRightOperandLogicalAndExpressionParserRuleCall_1_2_0()); }
	ruleLogicalAndExpression{ after(grammarAccess.getLogicalOrExpressionAccess().getRightOperandLogicalAndExpressionParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalAndExpression__RightOperandAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalAndExpressionAccess().getRightOperandEqualityExpressionParserRuleCall_1_2_0()); }
	ruleEqualityExpression{ after(grammarAccess.getLogicalAndExpressionAccess().getRightOperandEqualityExpressionParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EqualityExpression__OperatorAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEqualityExpressionAccess().getOperatorEqualityOperatorEnumRuleCall_1_1_0()); }
	ruleEqualityOperator{ after(grammarAccess.getEqualityExpressionAccess().getOperatorEqualityOperatorEnumRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EqualityExpression__RightOperandAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEqualityExpressionAccess().getRightOperandRelationalExpressionParserRuleCall_1_2_0()); }
	ruleRelationalExpression{ after(grammarAccess.getEqualityExpressionAccess().getRightOperandRelationalExpressionParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalExpression__OperatorAssignment_1_0_0_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalExpressionAccess().getOperatorRelationalOperatorEnumRuleCall_1_0_0_1_0()); }
	ruleRelationalOperator{ after(grammarAccess.getRelationalExpressionAccess().getOperatorRelationalOperatorEnumRuleCall_1_0_0_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalExpression__RightOperandAssignment_1_0_0_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalExpressionAccess().getRightOperandAdditiveExpressionParserRuleCall_1_0_0_2_0()); }
	ruleAdditiveExpression{ after(grammarAccess.getRelationalExpressionAccess().getRightOperandAdditiveExpressionParserRuleCall_1_0_0_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RelationalExpression__TypeAssignment_1_0_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelationalExpressionAccess().getTypeDataTypeSpecifierParserRuleCall_1_0_1_2_0()); }
	ruleDataTypeSpecifier{ after(grammarAccess.getRelationalExpressionAccess().getTypeDataTypeSpecifierParserRuleCall_1_0_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveExpression__OperatorAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAdditiveExpressionAccess().getOperatorAdditiveOperatorEnumRuleCall_1_1_0()); }
	ruleAdditiveOperator{ after(grammarAccess.getAdditiveExpressionAccess().getOperatorAdditiveOperatorEnumRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveExpression__RightOperandAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAdditiveExpressionAccess().getRightOperandMultiplicativeExpressionParserRuleCall_1_2_0()); }
	ruleMultiplicativeExpression{ after(grammarAccess.getAdditiveExpressionAccess().getRightOperandMultiplicativeExpressionParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeExpression__OperatorAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMultiplicativeExpressionAccess().getOperatorMultiplicativeOperatorEnumRuleCall_1_1_0()); }
	ruleMultiplicativeOperator{ after(grammarAccess.getMultiplicativeExpressionAccess().getOperatorMultiplicativeOperatorEnumRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeExpression__RightOperandAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMultiplicativeExpressionAccess().getRightOperandPowerExpressionParserRuleCall_1_2_0()); }
	rulePowerExpression{ after(grammarAccess.getMultiplicativeExpressionAccess().getRightOperandPowerExpressionParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PowerExpression__OperatorAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPowerExpressionAccess().getOperatorPowerOperatorEnumRuleCall_1_1_0()); }
	rulePowerOperator{ after(grammarAccess.getPowerExpressionAccess().getOperatorPowerOperatorEnumRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PowerExpression__ExponentAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPowerExpressionAccess().getExponentUnaryExpressionParserRuleCall_1_2_0()); }
	ruleUnaryExpression{ after(grammarAccess.getPowerExpressionAccess().getExponentUnaryExpressionParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__OperatorAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnaryExpressionAccess().getOperatorUnaryOperatorEnumRuleCall_1_1_0()); }
	ruleUnaryOperator{ after(grammarAccess.getUnaryExpressionAccess().getOperatorUnaryOperatorEnumRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__OperandAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnaryExpressionAccess().getOperandPostfixExpressionParserRuleCall_1_2_0()); }
	rulePostfixExpression{ after(grammarAccess.getUnaryExpressionAccess().getOperandPostfixExpressionParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PostfixExpression__OperatorAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPostfixExpressionAccess().getOperatorPostfixOperatorEnumRuleCall_1_1_0()); }
	rulePostfixOperator{ after(grammarAccess.getPostfixExpressionAccess().getOperatorPostfixOperatorEnumRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayElementAccess__SubscriptsAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayElementAccessAccess().getSubscriptsArraySubscriptParserRuleCall_1_2_0()); }
	ruleArraySubscript{ after(grammarAccess.getArrayElementAccessAccess().getSubscriptsArraySubscriptParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayElementAccess__SubscriptsAssignment_1_3_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayElementAccessAccess().getSubscriptsArraySubscriptParserRuleCall_1_3_1_0()); }
	ruleArraySubscript{ after(grammarAccess.getArrayElementAccessAccess().getSubscriptsArraySubscriptParserRuleCall_1_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__MemberVariableAssignment_1_0_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getMemberVariableCallableElementCrossReference_1_0_2_0()); }
(
{ before(grammarAccess.getMemberFeatureCallAccess().getMemberVariableCallableElementValidIDParserRuleCall_1_0_2_0_1()); }
	ruleValidID{ after(grammarAccess.getMemberFeatureCallAccess().getMemberVariableCallableElementValidIDParserRuleCall_1_0_2_0_1()); }
)
{ after(grammarAccess.getMemberFeatureCallAccess().getMemberVariableCallableElementCrossReference_1_0_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__FeatureAssignment_1_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getFeatureCallableElementCrossReference_1_1_2_0()); }
(
{ before(grammarAccess.getMemberFeatureCallAccess().getFeatureCallableElementValidIDParserRuleCall_1_1_2_0_1()); }
	ruleValidID{ after(grammarAccess.getMemberFeatureCallAccess().getFeatureCallableElementValidIDParserRuleCall_1_1_2_0_1()); }
)
{ after(grammarAccess.getMemberFeatureCallAccess().getFeatureCallableElementCrossReference_1_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__ArgumentsAssignment_1_1_4_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getArgumentsExpressionParserRuleCall_1_1_4_0_0()); }
	ruleExpression{ after(grammarAccess.getMemberFeatureCallAccess().getArgumentsExpressionParserRuleCall_1_1_4_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__ArgumentsAssignment_1_1_4_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getArgumentsExpressionParserRuleCall_1_1_4_1_1_0()); }
	ruleExpression{ after(grammarAccess.getMemberFeatureCallAccess().getArgumentsExpressionParserRuleCall_1_1_4_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__IdentifierAssignment_1_2_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getIdentifierValidIDParserRuleCall_1_2_2_0()); }
	ruleValidID{ after(grammarAccess.getMemberFeatureCallAccess().getIdentifierValidIDParserRuleCall_1_2_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__VariablesAssignment_1_2_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getVariablesIterationVariableParserRuleCall_1_2_4_0()); }
	ruleIterationVariable{ after(grammarAccess.getMemberFeatureCallAccess().getVariablesIterationVariableParserRuleCall_1_2_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__VariablesAssignment_1_2_5_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getVariablesIterationVariableParserRuleCall_1_2_5_1_0()); }
	ruleIterationVariable{ after(grammarAccess.getMemberFeatureCallAccess().getVariablesIterationVariableParserRuleCall_1_2_5_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__AccumulatorAssignment_1_2_6_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getAccumulatorIterationAccumulatorParserRuleCall_1_2_6_1_0()); }
	ruleIterationAccumulator{ after(grammarAccess.getMemberFeatureCallAccess().getAccumulatorIterationAccumulatorParserRuleCall_1_2_6_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__BreakConditionAssignment_1_2_7_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getBreakConditionExpressionParserRuleCall_1_2_7_1_0()); }
	ruleExpression{ after(grammarAccess.getMemberFeatureCallAccess().getBreakConditionExpressionParserRuleCall_1_2_7_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MemberFeatureCall__ExpressionAssignment_1_2_9
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMemberFeatureCallAccess().getExpressionExpressionParserRuleCall_1_2_9_0()); }
	ruleExpression{ after(grammarAccess.getMemberFeatureCallAccess().getExpressionExpressionParserRuleCall_1_2_9_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AssignableMemberFeatureCall__MemberVariableAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssignableMemberFeatureCallAccess().getMemberVariableCallableElementCrossReference_1_2_0()); }
(
{ before(grammarAccess.getAssignableMemberFeatureCallAccess().getMemberVariableCallableElementValidIDParserRuleCall_1_2_0_1()); }
	ruleValidID{ after(grammarAccess.getAssignableMemberFeatureCallAccess().getMemberVariableCallableElementValidIDParserRuleCall_1_2_0_1()); }
)
{ after(grammarAccess.getAssignableMemberFeatureCallAccess().getMemberVariableCallableElementCrossReference_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IterationVariable__NameAssignment
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIterationVariableAccess().getNameValidIDParserRuleCall_0()); }
	ruleValidID{ after(grammarAccess.getIterationVariableAccess().getNameValidIDParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IterationAccumulator__NameAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIterationAccumulatorAccess().getNameValidIDParserRuleCall_0_0()); }
	ruleValidID{ after(grammarAccess.getIterationAccumulatorAccess().getNameValidIDParserRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IterationAccumulator__InitializerAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIterationAccumulatorAccess().getInitializerExpressionParserRuleCall_2_0()); }
	ruleExpression{ after(grammarAccess.getIterationAccumulatorAccess().getInitializerExpressionParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArraySubscript__SliceAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArraySubscriptAccess().getSliceColonKeyword_0_0()); }
(
{ before(grammarAccess.getArraySubscriptAccess().getSliceColonKeyword_0_0()); }

	':' 

{ after(grammarAccess.getArraySubscriptAccess().getSliceColonKeyword_0_0()); }
)

{ after(grammarAccess.getArraySubscriptAccess().getSliceColonKeyword_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArraySubscript__ExpressionAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArraySubscriptAccess().getExpressionExpressionParserRuleCall_1_0()); }
	ruleExpression{ after(grammarAccess.getArraySubscriptAccess().getExpressionExpressionParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RealLiteral__ValueAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealLiteralAccess().getValueValidDoubleParserRuleCall_0_0()); }
	ruleValidDouble{ after(grammarAccess.getRealLiteralAccess().getValueValidDoubleParserRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RealLiteral__ModifierAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealLiteralAccess().getModifierValidIDParserRuleCall_1_0()); }
	ruleValidID{ after(grammarAccess.getRealLiteralAccess().getModifierValidIDParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RealLiteral__UnitAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealLiteralAccess().getUnitUnitParserRuleCall_2_0()); }
	ruleUnit{ after(grammarAccess.getRealLiteralAccess().getUnitUnitParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerLiteral__ValueAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntegerLiteralAccess().getValueValidLongParserRuleCall_0_0()); }
	ruleValidLong{ after(grammarAccess.getIntegerLiteralAccess().getValueValidLongParserRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerLiteral__ModifierAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntegerLiteralAccess().getModifierValidIDParserRuleCall_1_0()); }
	ruleValidID{ after(grammarAccess.getIntegerLiteralAccess().getModifierValidIDParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerLiteral__UnitAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntegerLiteralAccess().getUnitUnitParserRuleCall_2_0()); }
	ruleUnit{ after(grammarAccess.getIntegerLiteralAccess().getUnitUnitParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__TrueAssignment_1_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBooleanLiteralAccess().getTrueTrueKeyword_1_0_0()); }
(
{ before(grammarAccess.getBooleanLiteralAccess().getTrueTrueKeyword_1_0_0()); }

	'true' 

{ after(grammarAccess.getBooleanLiteralAccess().getTrueTrueKeyword_1_0_0()); }
)

{ after(grammarAccess.getBooleanLiteralAccess().getTrueTrueKeyword_1_0_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__VariableAccess__FeatureAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableAccessAccess().getFeatureCallableElementCrossReference_1_0()); }
(
{ before(grammarAccess.getVariableAccessAccess().getFeatureCallableElementQualifiedNameParserRuleCall_1_0_1()); }
	ruleQualifiedName{ after(grammarAccess.getVariableAccessAccess().getFeatureCallableElementQualifiedNameParserRuleCall_1_0_1()); }
)
{ after(grammarAccess.getVariableAccessAccess().getFeatureCallableElementCrossReference_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__VariableAccess__StepExpressionAssignment_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableAccessAccess().getStepExpressionStepExpressionParserRuleCall_2_1_0()); }
	ruleStepExpression{ after(grammarAccess.getVariableAccessAccess().getStepExpressionStepExpressionParserRuleCall_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionCall__FeatureAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionCallAccess().getFeatureCallableElementCrossReference_1_0()); }
(
{ before(grammarAccess.getFunctionCallAccess().getFeatureCallableElementQualifiedNameParserRuleCall_1_0_1()); }
	ruleQualifiedName{ after(grammarAccess.getFunctionCallAccess().getFeatureCallableElementQualifiedNameParserRuleCall_1_0_1()); }
)
{ after(grammarAccess.getFunctionCallAccess().getFeatureCallableElementCrossReference_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionCall__ArgumentsAssignment_3_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionCallAccess().getArgumentsExpressionParserRuleCall_3_0_0()); }
	ruleExpression{ after(grammarAccess.getFunctionCallAccess().getArgumentsExpressionParserRuleCall_3_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionCall__ArgumentsAssignment_3_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFunctionCallAccess().getArgumentsExpressionParserRuleCall_3_1_1_0()); }
	ruleExpression{ after(grammarAccess.getFunctionCallAccess().getArgumentsExpressionParserRuleCall_3_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RangeStepExpression__EndAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRangeStepExpressionAccess().getEndAdditiveStepExpressionParserRuleCall_1_2_0()); }
	ruleAdditiveStepExpression{ after(grammarAccess.getRangeStepExpressionAccess().getEndAdditiveStepExpressionParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveStepExpression__OperatorAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAdditiveStepExpressionAccess().getOperatorAdditiveOperatorEnumRuleCall_1_1_0()); }
	ruleAdditiveOperator{ after(grammarAccess.getAdditiveStepExpressionAccess().getOperatorAdditiveOperatorEnumRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveStepExpression__RightOperandAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAdditiveStepExpressionAccess().getRightOperandNegateStepExpressionParserRuleCall_1_2_0()); }
	ruleNegateStepExpression{ after(grammarAccess.getAdditiveStepExpressionAccess().getRightOperandNegateStepExpressionParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__NegateStepExpression__OperandAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getNegateStepExpressionAccess().getOperandPrimitiveStepExpressionParserRuleCall_1_2_0()); }
	rulePrimitiveStepExpression{ after(grammarAccess.getNegateStepExpressionAccess().getOperandPrimitiveStepExpressionParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StepLiteral__ValueAssignment
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStepLiteralAccess().getValueValidIntParserRuleCall_0()); }
	ruleValidInt{ after(grammarAccess.getStepLiteralAccess().getValueValidIntParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DerivativeOperator__VariableAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDerivativeOperatorAccess().getVariableCallableElementCrossReference_1_0()); }
(
{ before(grammarAccess.getDerivativeOperatorAccess().getVariableCallableElementValidIDParserRuleCall_1_0_1()); }
	ruleValidID{ after(grammarAccess.getDerivativeOperatorAccess().getVariableCallableElementValidIDParserRuleCall_1_0_1()); }
)
{ after(grammarAccess.getDerivativeOperatorAccess().getVariableCallableElementCrossReference_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__ExpressionsAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getExpressionsExpressionParserRuleCall_1_0()); }
	ruleExpression{ after(grammarAccess.getArrayConstructionOperatorAccess().getExpressionsExpressionParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__ExpressionsAssignment_2_0_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getExpressionsExpressionParserRuleCall_2_0_1_0()); }
	ruleExpression{ after(grammarAccess.getArrayConstructionOperatorAccess().getExpressionsExpressionParserRuleCall_2_0_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__IterationClausesAssignment_2_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getIterationClausesArrayConstructionIterationClauseParserRuleCall_2_1_1_0()); }
	ruleArrayConstructionIterationClause{ after(grammarAccess.getArrayConstructionOperatorAccess().getIterationClausesArrayConstructionIterationClauseParserRuleCall_2_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionOperator__IterationClausesAssignment_2_1_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionOperatorAccess().getIterationClausesArrayConstructionIterationClauseParserRuleCall_2_1_2_1_0()); }
	ruleArrayConstructionIterationClause{ after(grammarAccess.getArrayConstructionOperatorAccess().getIterationClausesArrayConstructionIterationClauseParserRuleCall_2_1_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionIterationClause__VariableNameAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionIterationClauseAccess().getVariableNameValidIDParserRuleCall_0_0()); }
	ruleValidID{ after(grammarAccess.getArrayConstructionIterationClauseAccess().getVariableNameValidIDParserRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConstructionIterationClause__CollectionExpressionAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConstructionIterationClauseAccess().getCollectionExpressionExpressionParserRuleCall_2_0()); }
	ruleExpression{ after(grammarAccess.getArrayConstructionIterationClauseAccess().getCollectionExpressionExpressionParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConcatenationOperator__RowsAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConcatenationOperatorAccess().getRowsExpressionListParserRuleCall_1_0()); }
	ruleExpressionList{ after(grammarAccess.getArrayConcatenationOperatorAccess().getRowsExpressionListParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayConcatenationOperator__RowsAssignment_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getArrayConcatenationOperatorAccess().getRowsExpressionListParserRuleCall_2_1_0()); }
	ruleExpressionList{ after(grammarAccess.getArrayConcatenationOperatorAccess().getRowsExpressionListParserRuleCall_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ExpressionList__ExpressionsAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExpressionListAccess().getExpressionsExpressionParserRuleCall_0_0()); }
	ruleExpression{ after(grammarAccess.getExpressionListAccess().getExpressionsExpressionParserRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ExpressionList__ExpressionsAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExpressionListAccess().getExpressionsExpressionParserRuleCall_1_1_0()); }
	ruleExpression{ after(grammarAccess.getExpressionListAccess().getExpressionsExpressionParserRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnitConstructionOperator__UnitAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitConstructionOperatorAccess().getUnitExplicitUnitParserRuleCall_1_0()); }
	ruleExplicitUnit{ after(grammarAccess.getUnitConstructionOperatorAccess().getUnitExplicitUnitParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ParenthesizedExpression__ExpressionsAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getParenthesizedExpressionAccess().getExpressionsExpressionParserRuleCall_1_0()); }
	ruleExpression{ after(grammarAccess.getParenthesizedExpressionAccess().getExpressionsExpressionParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ParenthesizedExpression__ExpressionsAssignment_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getParenthesizedExpressionAccess().getExpressionsExpressionParserRuleCall_2_1_0()); }
	ruleExpression{ after(grammarAccess.getParenthesizedExpressionAccess().getExpressionsExpressionParserRuleCall_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AlgorithmExpression__BodyAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAlgorithmExpressionAccess().getBodyCompoundParserRuleCall_2_0()); }
	ruleCompound{ after(grammarAccess.getAlgorithmExpressionAccess().getBodyCompoundParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Compound__StatementsAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundAccess().getStatementsStatementParserRuleCall_2_0()); }
	ruleStatement{ after(grammarAccess.getCompoundAccess().getStatementsStatementParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Assignment__TargetAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssignmentAccess().getTargetAssignableMemberFeatureCallParserRuleCall_0_0()); }
	ruleAssignableMemberFeatureCall{ after(grammarAccess.getAssignmentAccess().getTargetAssignableMemberFeatureCallParserRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Assignment__ExpressionAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAssignmentAccess().getExpressionExpressionParserRuleCall_2_0()); }
	ruleExpression{ after(grammarAccess.getAssignmentAccess().getExpressionExpressionParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__VariableDeclaration__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableDeclarationAccess().getNameValidIDParserRuleCall_1_0()); }
	ruleValidID{ after(grammarAccess.getVariableDeclarationAccess().getNameValidIDParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__VariableDeclaration__InitializerAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVariableDeclarationAccess().getInitializerExpressionParserRuleCall_3_0()); }
	ruleExpression{ after(grammarAccess.getVariableDeclarationAccess().getInitializerExpressionParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IfStatement__ConditionAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfStatementAccess().getConditionExpressionParserRuleCall_2_0()); }
	ruleExpression{ after(grammarAccess.getIfStatementAccess().getConditionExpressionParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IfStatement__ThenStatementAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfStatementAccess().getThenStatementStatementParserRuleCall_4_0()); }
	ruleStatement{ after(grammarAccess.getIfStatementAccess().getThenStatementStatementParserRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IfStatement__ElseStatementAssignment_5_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIfStatementAccess().getElseStatementStatementParserRuleCall_5_1_0()); }
	ruleStatement{ after(grammarAccess.getIfStatementAccess().getElseStatementStatementParserRuleCall_5_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__ConditionAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getWhileStatementAccess().getConditionExpressionParserRuleCall_2_0()); }
	ruleExpression{ after(grammarAccess.getWhileStatementAccess().getConditionExpressionParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__BodyAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getWhileStatementAccess().getBodyStatementParserRuleCall_4_0()); }
	ruleStatement{ after(grammarAccess.getWhileStatementAccess().getBodyStatementParserRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ForStatement__IterationVariableAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getForStatementAccess().getIterationVariableIterationVariableParserRuleCall_2_0()); }
	ruleIterationVariable{ after(grammarAccess.getForStatementAccess().getIterationVariableIterationVariableParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ForStatement__CollectionExpressionAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getForStatementAccess().getCollectionExpressionExpressionParserRuleCall_4_0()); }
	ruleExpression{ after(grammarAccess.getForStatementAccess().getCollectionExpressionExpressionParserRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ForStatement__BodyAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getForStatementAccess().getBodyStatementParserRuleCall_6_0()); }
	ruleStatement{ after(grammarAccess.getForStatementAccess().getBodyStatementParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DoWhileStatement__BodyAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDoWhileStatementAccess().getBodyStatementParserRuleCall_1_0()); }
	ruleStatement{ after(grammarAccess.getDoWhileStatementAccess().getBodyStatementParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DoWhileStatement__ConditionAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDoWhileStatementAccess().getConditionExpressionParserRuleCall_4_0()); }
	ruleExpression{ after(grammarAccess.getDoWhileStatementAccess().getConditionExpressionParserRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ReturnStatement__ExpressionAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getReturnStatementAccess().getExpressionExpressionParserRuleCall_1_0()); }
	ruleExpression{ after(grammarAccess.getReturnStatementAccess().getExpressionExpressionParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__NumeratorAssignment_1_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getNumeratorUnitNumeratorParserRuleCall_1_1_1_0()); }
	ruleUnitNumerator{ after(grammarAccess.getUnitAccess().getNumeratorUnitNumeratorParserRuleCall_1_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__DenominatorAssignment_1_1_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getDenominatorUnitDenominatorParserRuleCall_1_1_2_1_0()); }
	ruleUnitDenominator{ after(grammarAccess.getUnitAccess().getDenominatorUnitDenominatorParserRuleCall_1_1_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Unit__NumeratorAssignment_1_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitAccess().getNumeratorImplicitUnitNumeratorParserRuleCall_1_2_0()); }
	ruleImplicitUnitNumerator{ after(grammarAccess.getUnitAccess().getNumeratorImplicitUnitNumeratorParserRuleCall_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ExplicitUnit__NumeratorAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExplicitUnitAccess().getNumeratorUnitNumeratorParserRuleCall_1_0()); }
	ruleUnitNumerator{ after(grammarAccess.getExplicitUnitAccess().getNumeratorUnitNumeratorParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ExplicitUnit__DenominatorAssignment_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExplicitUnitAccess().getDenominatorUnitDenominatorParserRuleCall_2_1_0()); }
	ruleUnitDenominator{ after(grammarAccess.getExplicitUnitAccess().getDenominatorUnitDenominatorParserRuleCall_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnitNumerator__FactorsAssignment_1_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitNumeratorAccess().getFactorsUnitFactorParserRuleCall_1_0_0()); }
	ruleUnitFactor{ after(grammarAccess.getUnitNumeratorAccess().getFactorsUnitFactorParserRuleCall_1_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnitNumerator__FactorsAssignment_1_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitNumeratorAccess().getFactorsUnitFactorParserRuleCall_1_1_1_0()); }
	ruleUnitFactor{ after(grammarAccess.getUnitNumeratorAccess().getFactorsUnitFactorParserRuleCall_1_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnitDenominator__FactorsAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitDenominatorAccess().getFactorsUnitFactorParserRuleCall_0_0()); }
	ruleUnitFactor{ after(grammarAccess.getUnitDenominatorAccess().getFactorsUnitFactorParserRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnitDenominator__FactorsAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitDenominatorAccess().getFactorsUnitFactorParserRuleCall_1_1_0()); }
	ruleUnitFactor{ after(grammarAccess.getUnitDenominatorAccess().getFactorsUnitFactorParserRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnitDenominator__FactorsAssignment_1_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitDenominatorAccess().getFactorsUnitFactorParserRuleCall_1_2_1_0()); }
	ruleUnitFactor{ after(grammarAccess.getUnitDenominatorAccess().getFactorsUnitFactorParserRuleCall_1_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnitFactor__SymbolAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitFactorAccess().getSymbolValidIDParserRuleCall_0_0()); }
	ruleValidID{ after(grammarAccess.getUnitFactorAccess().getSymbolValidIDParserRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UnitFactor__ExponentAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUnitFactorAccess().getExponentUnitExponentParserRuleCall_1_1_0()); }
	ruleUnitExponent{ after(grammarAccess.getUnitFactorAccess().getExponentUnitExponentParserRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


RULE_N : 'n';

RULE_ID : ('_'|'a'..'z'|'A'..'Z') ('0'..'9'|'_'|'a'..'z'|'A'..'Z')*;

RULE_STRING : '"' (~(('\\'|'"'))|'\\' ('\''|'"'|'?'|'\\'|'a'|'b'|'f'|'n'|'r'|'t'|'v'))* '"';

RULE_ONE : '1';

RULE_REAL : ('0'..'9')+ '.' ('0'..'9')* (('e'|'E') ('+'|'-')? ('0'..'9')+)?;

RULE_INT : ('0'..'9')+;

RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';

RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;

RULE_WS : (' '|'\t'|'\r'|'\n')+;

RULE_ANY_OTHER : .;


