org.eclipse.osbp.xtext.datamartdsl.ide/src-gen/org/eclipse/osbp/xtext/datamartdsl/ide/contentassist/antlr/internal/InternalDatamartDSL.g

/**
 *                                                                            
 *  Copyright (c) 2011, 2017 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
 *                                                                            
 *  All rights reserved. This program and the accompanying materials           
 *  are made available under the terms of the Eclipse Public License v1.0       
 *  which accompanies this distribution, and is available at                  
 *  http://www.eclipse.org/legal/epl-v10.html                                 
 *                                                                            
 *  Contributors:                                                      
 * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
 * 
 * generated by Xtext 2.11.0
 *
 */

grammar InternalDatamartDSL;

options {
	superClass=AbstractInternalContentAssistParser;
	backtrack=true;
}

@lexer::header {
package org.eclipse.osbp.xtext.datamartdsl.ide.contentassist.antlr.internal;

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

@parser::header {
package org.eclipse.osbp.xtext.datamartdsl.ide.contentassist.antlr.internal;

import java.io.InputStream;
import org.eclipse.xtext.*;
import org.eclipse.xtext.parser.*;
import org.eclipse.xtext.parser.impl.*;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.parser.antlr.XtextTokenStream;
import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
import org.eclipse.osbp.xtext.datamartdsl.services.DatamartDSLGrammarAccess;

}
@parser::members {
	private DatamartDSLGrammarAccess grammarAccess;

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

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

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

// Entry rule entryRuleDatamartModel
entryRuleDatamartModel
:
{ before(grammarAccess.getDatamartModelRule()); }
	 ruleDatamartModel
{ after(grammarAccess.getDatamartModelRule()); } 
	 EOF 
;

// Rule DatamartModel
ruleDatamartModel 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartModelAccess().getGroup()); }
		(rule__DatamartModel__Group__0)
		{ after(grammarAccess.getDatamartModelAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartPackage
entryRuleDatamartPackage
:
{ before(grammarAccess.getDatamartPackageRule()); }
	 ruleDatamartPackage
{ after(grammarAccess.getDatamartPackageRule()); } 
	 EOF 
;

// Rule DatamartPackage
ruleDatamartPackage 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartPackageAccess().getGroup()); }
		(rule__DatamartPackage__Group__0)
		{ after(grammarAccess.getDatamartPackageAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartDefinition
entryRuleDatamartDefinition
:
{ before(grammarAccess.getDatamartDefinitionRule()); }
	 ruleDatamartDefinition
{ after(grammarAccess.getDatamartDefinitionRule()); } 
	 EOF 
;

// Rule DatamartDefinition
ruleDatamartDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartDefinitionAccess().getGroup()); }
		(rule__DatamartDefinition__Group__0)
		{ after(grammarAccess.getDatamartDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartRole
entryRuleDatamartRole
:
{ before(grammarAccess.getDatamartRoleRule()); }
	 ruleDatamartRole
{ after(grammarAccess.getDatamartRoleRule()); } 
	 EOF 
;

// Rule DatamartRole
ruleDatamartRole 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartRoleAccess().getGroup()); }
		(rule__DatamartRole__Group__0)
		{ after(grammarAccess.getDatamartRoleAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartSource
entryRuleDatamartSource
:
{ before(grammarAccess.getDatamartSourceRule()); }
	 ruleDatamartSource
{ after(grammarAccess.getDatamartSourceRule()); } 
	 EOF 
;

// Rule DatamartSource
ruleDatamartSource 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartSourceAccess().getAlternatives()); }
		(rule__DatamartSource__Alternatives)
		{ after(grammarAccess.getDatamartSourceAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartTask
entryRuleDatamartTask
:
{ before(grammarAccess.getDatamartTaskRule()); }
	 ruleDatamartTask
{ after(grammarAccess.getDatamartTaskRule()); } 
	 EOF 
;

// Rule DatamartTask
ruleDatamartTask 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartTaskAccess().getGroup()); }
		(rule__DatamartTask__Group__0)
		{ after(grammarAccess.getDatamartTaskAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartColumn
entryRuleDatamartColumn
:
{ before(grammarAccess.getDatamartColumnRule()); }
	 ruleDatamartColumn
{ after(grammarAccess.getDatamartColumnRule()); } 
	 EOF 
;

// Rule DatamartColumn
ruleDatamartColumn 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartColumnAccess().getGroup()); }
		(rule__DatamartColumn__Group__0)
		{ after(grammarAccess.getDatamartColumnAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartTaskFilter
entryRuleDatamartTaskFilter
:
{ before(grammarAccess.getDatamartTaskFilterRule()); }
	 ruleDatamartTaskFilter
{ after(grammarAccess.getDatamartTaskFilterRule()); } 
	 EOF 
;

// Rule DatamartTaskFilter
ruleDatamartTaskFilter 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartTaskFilterAccess().getGroup()); }
		(rule__DatamartTaskFilter__Group__0)
		{ after(grammarAccess.getDatamartTaskFilterAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartCube
entryRuleDatamartCube
:
{ before(grammarAccess.getDatamartCubeRule()); }
	 ruleDatamartCube
{ after(grammarAccess.getDatamartCubeRule()); } 
	 EOF 
;

// Rule DatamartCube
ruleDatamartCube 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartCubeAccess().getGroup()); }
		(rule__DatamartCube__Group__0)
		{ after(grammarAccess.getDatamartCubeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartReference
entryRuleDatamartReference
:
{ before(grammarAccess.getDatamartReferenceRule()); }
	 ruleDatamartReference
{ after(grammarAccess.getDatamartReferenceRule()); } 
	 EOF 
;

// Rule DatamartReference
ruleDatamartReference 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartReferenceAccess().getGroup()); }
		(rule__DatamartReference__Group__0)
		{ after(grammarAccess.getDatamartReferenceAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartEntity
entryRuleDatamartEntity
:
{ before(grammarAccess.getDatamartEntityRule()); }
	 ruleDatamartEntity
{ after(grammarAccess.getDatamartEntityRule()); } 
	 EOF 
;

// Rule DatamartEntity
ruleDatamartEntity 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartEntityAccess().getGroup()); }
		(rule__DatamartEntity__Group__0)
		{ after(grammarAccess.getDatamartEntityAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartNavigation
entryRuleDatamartNavigation
:
{ before(grammarAccess.getDatamartNavigationRule()); }
	 ruleDatamartNavigation
{ after(grammarAccess.getDatamartNavigationRule()); } 
	 EOF 
;

// Rule DatamartNavigation
ruleDatamartNavigation 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartNavigationAccess().getAlternatives()); }
		(rule__DatamartNavigation__Alternatives)
		{ after(grammarAccess.getDatamartNavigationAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartOwner
entryRuleDatamartOwner
:
{ before(grammarAccess.getDatamartOwnerRule()); }
	 ruleDatamartOwner
{ after(grammarAccess.getDatamartOwnerRule()); } 
	 EOF 
;

// Rule DatamartOwner
ruleDatamartOwner 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartOwnerAccess().getGroup()); }
		(rule__DatamartOwner__Group__0)
		{ after(grammarAccess.getDatamartOwnerAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartMember
entryRuleDatamartMember
:
{ before(grammarAccess.getDatamartMemberRule()); }
	 ruleDatamartMember
{ after(grammarAccess.getDatamartMemberRule()); } 
	 EOF 
;

// Rule DatamartMember
ruleDatamartMember 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartMemberAccess().getGroup()); }
		(rule__DatamartMember__Group__0)
		{ after(grammarAccess.getDatamartMemberAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartAxis
entryRuleDatamartAxis
:
{ before(grammarAccess.getDatamartAxisRule()); }
	 ruleDatamartAxis
{ after(grammarAccess.getDatamartAxisRule()); } 
	 EOF 
;

// Rule DatamartAxis
ruleDatamartAxis 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartAxisAccess().getGroup()); }
		(rule__DatamartAxis__Group__0)
		{ after(grammarAccess.getDatamartAxisAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartAttributeBase
entryRuleDatamartAttributeBase
:
{ before(grammarAccess.getDatamartAttributeBaseRule()); }
	 ruleDatamartAttributeBase
{ after(grammarAccess.getDatamartAttributeBaseRule()); } 
	 EOF 
;

// Rule DatamartAttributeBase
ruleDatamartAttributeBase 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartAttributeBaseAccess().getGroup()); }
		(rule__DatamartAttributeBase__Group__0)
		{ after(grammarAccess.getDatamartAttributeBaseAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartAttribute
entryRuleDatamartAttribute
:
{ before(grammarAccess.getDatamartAttributeRule()); }
	 ruleDatamartAttribute
{ after(grammarAccess.getDatamartAttributeRule()); } 
	 EOF 
;

// Rule DatamartAttribute
ruleDatamartAttribute 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartAttributeAccess().getGroup()); }
		(rule__DatamartAttribute__Group__0)
		{ after(grammarAccess.getDatamartAttributeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartCondition
entryRuleDatamartCondition
:
{ before(grammarAccess.getDatamartConditionRule()); }
	 ruleDatamartCondition
{ after(grammarAccess.getDatamartConditionRule()); } 
	 EOF 
;

// Rule DatamartCondition
ruleDatamartCondition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartConditionAccess().getGroup()); }
		(rule__DatamartCondition__Group__0)
		{ after(grammarAccess.getDatamartConditionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartOrder
entryRuleDatamartOrder
:
{ before(grammarAccess.getDatamartOrderRule()); }
	 ruleDatamartOrder
{ after(grammarAccess.getDatamartOrderRule()); } 
	 EOF 
;

// Rule DatamartOrder
ruleDatamartOrder 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartOrderAccess().getGroup()); }
		(rule__DatamartOrder__Group__0)
		{ after(grammarAccess.getDatamartOrderAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartDisjunction
entryRuleDatamartDisjunction
:
{ before(grammarAccess.getDatamartDisjunctionRule()); }
	 ruleDatamartDisjunction
{ after(grammarAccess.getDatamartDisjunctionRule()); } 
	 EOF 
;

// Rule DatamartDisjunction
ruleDatamartDisjunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartDisjunctionAccess().getGroup()); }
		(rule__DatamartDisjunction__Group__0)
		{ after(grammarAccess.getDatamartDisjunctionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartConjunction
entryRuleDatamartConjunction
:
{ before(grammarAccess.getDatamartConjunctionRule()); }
	 ruleDatamartConjunction
{ after(grammarAccess.getDatamartConjunctionRule()); } 
	 EOF 
;

// Rule DatamartConjunction
ruleDatamartConjunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartConjunctionAccess().getGroup()); }
		(rule__DatamartConjunction__Group__0)
		{ after(grammarAccess.getDatamartConjunctionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartConditionalExpression
entryRuleDatamartConditionalExpression
:
{ before(grammarAccess.getDatamartConditionalExpressionRule()); }
	 ruleDatamartConditionalExpression
{ after(grammarAccess.getDatamartConditionalExpressionRule()); } 
	 EOF 
;

// Rule DatamartConditionalExpression
ruleDatamartConditionalExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartConditionalExpressionAccess().getGroup()); }
		(rule__DatamartConditionalExpression__Group__0)
		{ after(grammarAccess.getDatamartConditionalExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartOperand
entryRuleDatamartOperand
:
{ before(grammarAccess.getDatamartOperandRule()); }
	 ruleDatamartOperand
{ after(grammarAccess.getDatamartOperandRule()); } 
	 EOF 
;

// Rule DatamartOperand
ruleDatamartOperand 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartOperandAccess().getAlternatives()); }
		(rule__DatamartOperand__Alternatives)
		{ after(grammarAccess.getDatamartOperandAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartValue
entryRuleDatamartValue
:
{ before(grammarAccess.getDatamartValueRule()); }
	 ruleDatamartValue
{ after(grammarAccess.getDatamartValueRule()); } 
	 EOF 
;

// Rule DatamartValue
ruleDatamartValue 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartValueAccess().getAlternatives()); }
		(rule__DatamartValue__Alternatives)
		{ after(grammarAccess.getDatamartValueAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartCubeElement
entryRuleDatamartCubeElement
:
{ before(grammarAccess.getDatamartCubeElementRule()); }
	 ruleDatamartCubeElement
{ after(grammarAccess.getDatamartCubeElementRule()); } 
	 EOF 
;

// Rule DatamartCubeElement
ruleDatamartCubeElement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartCubeElementAccess().getAlternatives()); }
		(rule__DatamartCubeElement__Alternatives)
		{ after(grammarAccess.getDatamartCubeElementAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartDefineDerivedMeasure
entryRuleDatamartDefineDerivedMeasure
:
{ before(grammarAccess.getDatamartDefineDerivedMeasureRule()); }
	 ruleDatamartDefineDerivedMeasure
{ after(grammarAccess.getDatamartDefineDerivedMeasureRule()); } 
	 EOF 
;

// Rule DatamartDefineDerivedMeasure
ruleDatamartDefineDerivedMeasure 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartDefineDerivedMeasureAccess().getGroup()); }
		(rule__DatamartDefineDerivedMeasure__Group__0)
		{ after(grammarAccess.getDatamartDefineDerivedMeasureAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartAddition
entryRuleDatamartAddition
:
{ before(grammarAccess.getDatamartAdditionRule()); }
	 ruleDatamartAddition
{ after(grammarAccess.getDatamartAdditionRule()); } 
	 EOF 
;

// Rule DatamartAddition
ruleDatamartAddition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartAdditionAccess().getGroup()); }
		(rule__DatamartAddition__Group__0)
		{ after(grammarAccess.getDatamartAdditionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartMultiplication
entryRuleDatamartMultiplication
:
{ before(grammarAccess.getDatamartMultiplicationRule()); }
	 ruleDatamartMultiplication
{ after(grammarAccess.getDatamartMultiplicationRule()); } 
	 EOF 
;

// Rule DatamartMultiplication
ruleDatamartMultiplication 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartMultiplicationAccess().getGroup()); }
		(rule__DatamartMultiplication__Group__0)
		{ after(grammarAccess.getDatamartMultiplicationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartPrimary
entryRuleDatamartPrimary
:
{ before(grammarAccess.getDatamartPrimaryRule()); }
	 ruleDatamartPrimary
{ after(grammarAccess.getDatamartPrimaryRule()); } 
	 EOF 
;

// Rule DatamartPrimary
ruleDatamartPrimary 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartPrimaryAccess().getAlternatives()); }
		(rule__DatamartPrimary__Alternatives)
		{ after(grammarAccess.getDatamartPrimaryAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartNumberOrElement
entryRuleDatamartNumberOrElement
:
{ before(grammarAccess.getDatamartNumberOrElementRule()); }
	 ruleDatamartNumberOrElement
{ after(grammarAccess.getDatamartNumberOrElementRule()); } 
	 EOF 
;

// Rule DatamartNumberOrElement
ruleDatamartNumberOrElement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartNumberOrElementAccess().getAlternatives()); }
		(rule__DatamartNumberOrElement__Alternatives)
		{ after(grammarAccess.getDatamartNumberOrElementAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartMemberTuple
entryRuleDatamartMemberTuple
:
{ before(grammarAccess.getDatamartMemberTupleRule()); }
	 ruleDatamartMemberTuple
{ after(grammarAccess.getDatamartMemberTupleRule()); } 
	 EOF 
;

// Rule DatamartMemberTuple
ruleDatamartMemberTuple 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartMemberTupleAccess().getGroup()); }
		(rule__DatamartMemberTuple__Group__0)
		{ after(grammarAccess.getDatamartMemberTupleAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartFunction
entryRuleDatamartFunction
:
{ before(grammarAccess.getDatamartFunctionRule()); }
	 ruleDatamartFunction
{ after(grammarAccess.getDatamartFunctionRule()); } 
	 EOF 
;

// Rule DatamartFunction
ruleDatamartFunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartFunctionAccess().getFunctionAssignment()); }
		(rule__DatamartFunction__FunctionAssignment)
		{ after(grammarAccess.getDatamartFunctionAccess().getFunctionAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartParameterFunction
entryRuleDatamartParameterFunction
:
{ before(grammarAccess.getDatamartParameterFunctionRule()); }
	 ruleDatamartParameterFunction
{ after(grammarAccess.getDatamartParameterFunctionRule()); } 
	 EOF 
;

// Rule DatamartParameterFunction
ruleDatamartParameterFunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartParameterFunctionAccess().getGroup()); }
		(rule__DatamartParameterFunction__Group__0)
		{ after(grammarAccess.getDatamartParameterFunctionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartFunctionIntParameter
entryRuleDatamartFunctionIntParameter
:
{ before(grammarAccess.getDatamartFunctionIntParameterRule()); }
	 ruleDatamartFunctionIntParameter
{ after(grammarAccess.getDatamartFunctionIntParameterRule()); } 
	 EOF 
;

// Rule DatamartFunctionIntParameter
ruleDatamartFunctionIntParameter 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartFunctionIntParameterAccess().getValueAssignment()); }
		(rule__DatamartFunctionIntParameter__ValueAssignment)
		{ after(grammarAccess.getDatamartFunctionIntParameterAccess().getValueAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartSetFunction
entryRuleDatamartSetFunction
:
{ before(grammarAccess.getDatamartSetFunctionRule()); }
	 ruleDatamartSetFunction
{ after(grammarAccess.getDatamartSetFunctionRule()); } 
	 EOF 
;

// Rule DatamartSetFunction
ruleDatamartSetFunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartSetFunctionAccess().getSetFunctionAssignment()); }
		(rule__DatamartSetFunction__SetFunctionAssignment)
		{ after(grammarAccess.getDatamartSetFunctionAccess().getSetFunctionAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartSetParameterFunction
entryRuleDatamartSetParameterFunction
:
{ before(grammarAccess.getDatamartSetParameterFunctionRule()); }
	 ruleDatamartSetParameterFunction
{ after(grammarAccess.getDatamartSetParameterFunctionRule()); } 
	 EOF 
;

// Rule DatamartSetParameterFunction
ruleDatamartSetParameterFunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartSetParameterFunctionAccess().getGroup()); }
		(rule__DatamartSetParameterFunction__Group__0)
		{ after(grammarAccess.getDatamartSetParameterFunctionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartSetAggregationFunction
entryRuleDatamartSetAggregationFunction
:
{ before(grammarAccess.getDatamartSetAggregationFunctionRule()); }
	 ruleDatamartSetAggregationFunction
{ after(grammarAccess.getDatamartSetAggregationFunctionRule()); } 
	 EOF 
;

// Rule DatamartSetAggregationFunction
ruleDatamartSetAggregationFunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartSetAggregationFunctionAccess().getGroup()); }
		(rule__DatamartSetAggregationFunction__Group__0)
		{ after(grammarAccess.getDatamartSetAggregationFunctionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartSetTuple
entryRuleDatamartSetTuple
:
{ before(grammarAccess.getDatamartSetTupleRule()); }
	 ruleDatamartSetTuple
{ after(grammarAccess.getDatamartSetTupleRule()); } 
	 EOF 
;

// Rule DatamartSetTuple
ruleDatamartSetTuple 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartSetTupleAccess().getGroup()); }
		(rule__DatamartSetTuple__Group__0)
		{ after(grammarAccess.getDatamartSetTupleAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartAggregationFunction
entryRuleDatamartAggregationFunction
:
{ before(grammarAccess.getDatamartAggregationFunctionRule()); }
	 ruleDatamartAggregationFunction
{ after(grammarAccess.getDatamartAggregationFunctionRule()); } 
	 EOF 
;

// Rule DatamartAggregationFunction
ruleDatamartAggregationFunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartAggregationFunctionAccess().getAggregationAssignment()); }
		(rule__DatamartAggregationFunction__AggregationAssignment)
		{ after(grammarAccess.getDatamartAggregationFunctionAccess().getAggregationAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartAggregation
entryRuleDatamartAggregation
:
{ before(grammarAccess.getDatamartAggregationRule()); }
	 ruleDatamartAggregation
{ after(grammarAccess.getDatamartAggregationRule()); } 
	 EOF 
;

// Rule DatamartAggregation
ruleDatamartAggregation 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartAggregationAccess().getGroup()); }
		(rule__DatamartAggregation__Group__0)
		{ after(grammarAccess.getDatamartAggregationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartSetAggregation
entryRuleDatamartSetAggregation
:
{ before(grammarAccess.getDatamartSetAggregationRule()); }
	 ruleDatamartSetAggregation
{ after(grammarAccess.getDatamartSetAggregationRule()); } 
	 EOF 
;

// Rule DatamartSetAggregation
ruleDatamartSetAggregation 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartSetAggregationAccess().getGroup()); }
		(rule__DatamartSetAggregation__Group__0)
		{ after(grammarAccess.getDatamartSetAggregationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartSlicer
entryRuleDatamartSlicer
:
{ before(grammarAccess.getDatamartSlicerRule()); }
	 ruleDatamartSlicer
{ after(grammarAccess.getDatamartSlicerRule()); } 
	 EOF 
;

// Rule DatamartSlicer
ruleDatamartSlicer 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartSlicerAccess().getGroup()); }
		(rule__DatamartSlicer__Group__0)
		{ after(grammarAccess.getDatamartSlicerAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartCubeAxis
entryRuleDatamartCubeAxis
:
{ before(grammarAccess.getDatamartCubeAxisRule()); }
	 ruleDatamartCubeAxis
{ after(grammarAccess.getDatamartCubeAxisRule()); } 
	 EOF 
;

// Rule DatamartCubeAxis
ruleDatamartCubeAxis 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartCubeAxisAccess().getGroup()); }
		(rule__DatamartCubeAxis__Group__0)
		{ after(grammarAccess.getDatamartCubeAxisAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartElement
entryRuleDatamartElement
:
{ before(grammarAccess.getDatamartElementRule()); }
	 ruleDatamartElement
{ after(grammarAccess.getDatamartElementRule()); } 
	 EOF 
;

// Rule DatamartElement
ruleDatamartElement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartElementAccess().getAlternatives()); }
		(rule__DatamartElement__Alternatives)
		{ after(grammarAccess.getDatamartElementAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartDerivedMeasure
entryRuleDatamartDerivedMeasure
:
{ before(grammarAccess.getDatamartDerivedMeasureRule()); }
	 ruleDatamartDerivedMeasure
{ after(grammarAccess.getDatamartDerivedMeasureRule()); } 
	 EOF 
;

// Rule DatamartDerivedMeasure
ruleDatamartDerivedMeasure 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartDerivedMeasureAccess().getGroup()); }
		(rule__DatamartDerivedMeasure__Group__0)
		{ after(grammarAccess.getDatamartDerivedMeasureAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartMeasure
entryRuleDatamartMeasure
:
{ before(grammarAccess.getDatamartMeasureRule()); }
	 ruleDatamartMeasure
{ after(grammarAccess.getDatamartMeasureRule()); } 
	 EOF 
;

// Rule DatamartMeasure
ruleDatamartMeasure 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartMeasureAccess().getGroup()); }
		(rule__DatamartMeasure__Group__0)
		{ after(grammarAccess.getDatamartMeasureAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDatamartHierarchy
entryRuleDatamartHierarchy
:
{ before(grammarAccess.getDatamartHierarchyRule()); }
	 ruleDatamartHierarchy
{ after(grammarAccess.getDatamartHierarchyRule()); } 
	 EOF 
;

// Rule DatamartHierarchy
ruleDatamartHierarchy 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDatamartHierarchyAccess().getGroup()); }
		(rule__DatamartHierarchy__Group__0)
		{ after(grammarAccess.getDatamartHierarchyAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleTRANSLATABLESTRING
entryRuleTRANSLATABLESTRING
:
{ before(grammarAccess.getTRANSLATABLESTRINGRule()); }
	 ruleTRANSLATABLESTRING
{ after(grammarAccess.getTRANSLATABLESTRINGRule()); } 
	 EOF 
;

// Rule TRANSLATABLESTRING
ruleTRANSLATABLESTRING 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getTRANSLATABLESTRINGAccess().getSTRINGTerminalRuleCall()); }
		RULE_STRING
		{ after(grammarAccess.getTRANSLATABLESTRINGAccess().getSTRINGTerminalRuleCall()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleTRANSLATABLEID
entryRuleTRANSLATABLEID
:
{ before(grammarAccess.getTRANSLATABLEIDRule()); }
	 ruleTRANSLATABLEID
{ after(grammarAccess.getTRANSLATABLEIDRule()); } 
	 EOF 
;

// Rule TRANSLATABLEID
ruleTRANSLATABLEID 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getTRANSLATABLEIDAccess().getIDTerminalRuleCall()); }
		RULE_ID
		{ after(grammarAccess.getTRANSLATABLEIDAccess().getIDTerminalRuleCall()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerData
entryRuleAttributeFillerData
:
{ before(grammarAccess.getAttributeFillerDataRule()); }
	 ruleAttributeFillerData
{ after(grammarAccess.getAttributeFillerDataRule()); } 
	 EOF 
;

// Rule AttributeFillerData
ruleAttributeFillerData 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerDataAccess().getGroup()); }
		(rule__AttributeFillerData__Group__0)
		{ after(grammarAccess.getAttributeFillerDataAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerType
entryRuleAttributeFillerType
:
{ before(grammarAccess.getAttributeFillerTypeRule()); }
	 ruleAttributeFillerType
{ after(grammarAccess.getAttributeFillerTypeRule()); } 
	 EOF 
;

// Rule AttributeFillerType
ruleAttributeFillerType 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerTypeAccess().getAlternatives()); }
		(rule__AttributeFillerType__Alternatives)
		{ after(grammarAccess.getAttributeFillerTypeAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerDateFuture
entryRuleAttributeFillerDateFuture
:
{ before(grammarAccess.getAttributeFillerDateFutureRule()); }
	 ruleAttributeFillerDateFuture
{ after(grammarAccess.getAttributeFillerDateFutureRule()); } 
	 EOF 
;

// Rule AttributeFillerDateFuture
ruleAttributeFillerDateFuture 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerDateFutureAccess().getGroup()); }
		(rule__AttributeFillerDateFuture__Group__0)
		{ after(grammarAccess.getAttributeFillerDateFutureAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerDatePast
entryRuleAttributeFillerDatePast
:
{ before(grammarAccess.getAttributeFillerDatePastRule()); }
	 ruleAttributeFillerDatePast
{ after(grammarAccess.getAttributeFillerDatePastRule()); } 
	 EOF 
;

// Rule AttributeFillerDatePast
ruleAttributeFillerDatePast 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerDatePastAccess().getGroup()); }
		(rule__AttributeFillerDatePast__Group__0)
		{ after(grammarAccess.getAttributeFillerDatePastAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerDateRange
entryRuleAttributeFillerDateRange
:
{ before(grammarAccess.getAttributeFillerDateRangeRule()); }
	 ruleAttributeFillerDateRange
{ after(grammarAccess.getAttributeFillerDateRangeRule()); } 
	 EOF 
;

// Rule AttributeFillerDateRange
ruleAttributeFillerDateRange 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerDateRangeAccess().getGroup()); }
		(rule__AttributeFillerDateRange__Group__0)
		{ after(grammarAccess.getAttributeFillerDateRangeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerSignedDoubleRange
entryRuleAttributeFillerSignedDoubleRange
:
{ before(grammarAccess.getAttributeFillerSignedDoubleRangeRule()); }
	 ruleAttributeFillerSignedDoubleRange
{ after(grammarAccess.getAttributeFillerSignedDoubleRangeRule()); } 
	 EOF 
;

// Rule AttributeFillerSignedDoubleRange
ruleAttributeFillerSignedDoubleRange 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerSignedDoubleRangeAccess().getGroup()); }
		(rule__AttributeFillerSignedDoubleRange__Group__0)
		{ after(grammarAccess.getAttributeFillerSignedDoubleRangeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerSignedDoubleRandom
entryRuleAttributeFillerSignedDoubleRandom
:
{ before(grammarAccess.getAttributeFillerSignedDoubleRandomRule()); }
	 ruleAttributeFillerSignedDoubleRandom
{ after(grammarAccess.getAttributeFillerSignedDoubleRandomRule()); } 
	 EOF 
;

// Rule AttributeFillerSignedDoubleRandom
ruleAttributeFillerSignedDoubleRandom 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerSignedDoubleRandomAccess().getGroup()); }
		(rule__AttributeFillerSignedDoubleRandom__Group__0)
		{ after(grammarAccess.getAttributeFillerSignedDoubleRandomAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerSignedIntegerRange
entryRuleAttributeFillerSignedIntegerRange
:
{ before(grammarAccess.getAttributeFillerSignedIntegerRangeRule()); }
	 ruleAttributeFillerSignedIntegerRange
{ after(grammarAccess.getAttributeFillerSignedIntegerRangeRule()); } 
	 EOF 
;

// Rule AttributeFillerSignedIntegerRange
ruleAttributeFillerSignedIntegerRange 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerSignedIntegerRangeAccess().getGroup()); }
		(rule__AttributeFillerSignedIntegerRange__Group__0)
		{ after(grammarAccess.getAttributeFillerSignedIntegerRangeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerSignedIntegerRandom
entryRuleAttributeFillerSignedIntegerRandom
:
{ before(grammarAccess.getAttributeFillerSignedIntegerRandomRule()); }
	 ruleAttributeFillerSignedIntegerRandom
{ after(grammarAccess.getAttributeFillerSignedIntegerRandomRule()); } 
	 EOF 
;

// Rule AttributeFillerSignedIntegerRandom
ruleAttributeFillerSignedIntegerRandom 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerSignedIntegerRandomAccess().getGroup()); }
		(rule__AttributeFillerSignedIntegerRandom__Group__0)
		{ after(grammarAccess.getAttributeFillerSignedIntegerRandomAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerTextRandom
entryRuleAttributeFillerTextRandom
:
{ before(grammarAccess.getAttributeFillerTextRandomRule()); }
	 ruleAttributeFillerTextRandom
{ after(grammarAccess.getAttributeFillerTextRandomRule()); } 
	 EOF 
;

// Rule AttributeFillerTextRandom
ruleAttributeFillerTextRandom 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerTextRandomAccess().getGroup()); }
		(rule__AttributeFillerTextRandom__Group__0)
		{ after(grammarAccess.getAttributeFillerTextRandomAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerTextParagraphs
entryRuleAttributeFillerTextParagraphs
:
{ before(grammarAccess.getAttributeFillerTextParagraphsRule()); }
	 ruleAttributeFillerTextParagraphs
{ after(grammarAccess.getAttributeFillerTextParagraphsRule()); } 
	 EOF 
;

// Rule AttributeFillerTextParagraphs
ruleAttributeFillerTextParagraphs 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerTextParagraphsAccess().getGroup()); }
		(rule__AttributeFillerTextParagraphs__Group__0)
		{ after(grammarAccess.getAttributeFillerTextParagraphsAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerTextSentences
entryRuleAttributeFillerTextSentences
:
{ before(grammarAccess.getAttributeFillerTextSentencesRule()); }
	 ruleAttributeFillerTextSentences
{ after(grammarAccess.getAttributeFillerTextSentencesRule()); } 
	 EOF 
;

// Rule AttributeFillerTextSentences
ruleAttributeFillerTextSentences 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerTextSentencesAccess().getGroup()); }
		(rule__AttributeFillerTextSentences__Group__0)
		{ after(grammarAccess.getAttributeFillerTextSentencesAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerTextWords
entryRuleAttributeFillerTextWords
:
{ before(grammarAccess.getAttributeFillerTextWordsRule()); }
	 ruleAttributeFillerTextWords
{ after(grammarAccess.getAttributeFillerTextWordsRule()); } 
	 EOF 
;

// Rule AttributeFillerTextWords
ruleAttributeFillerTextWords 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerTextWordsAccess().getGroup()); }
		(rule__AttributeFillerTextWords__Group__0)
		{ after(grammarAccess.getAttributeFillerTextWordsAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerUnsignedDoubleRange
entryRuleAttributeFillerUnsignedDoubleRange
:
{ before(grammarAccess.getAttributeFillerUnsignedDoubleRangeRule()); }
	 ruleAttributeFillerUnsignedDoubleRange
{ after(grammarAccess.getAttributeFillerUnsignedDoubleRangeRule()); } 
	 EOF 
;

// Rule AttributeFillerUnsignedDoubleRange
ruleAttributeFillerUnsignedDoubleRange 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerUnsignedDoubleRangeAccess().getGroup()); }
		(rule__AttributeFillerUnsignedDoubleRange__Group__0)
		{ after(grammarAccess.getAttributeFillerUnsignedDoubleRangeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerUnsignedDoubleRandom
entryRuleAttributeFillerUnsignedDoubleRandom
:
{ before(grammarAccess.getAttributeFillerUnsignedDoubleRandomRule()); }
	 ruleAttributeFillerUnsignedDoubleRandom
{ after(grammarAccess.getAttributeFillerUnsignedDoubleRandomRule()); } 
	 EOF 
;

// Rule AttributeFillerUnsignedDoubleRandom
ruleAttributeFillerUnsignedDoubleRandom 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerUnsignedDoubleRandomAccess().getGroup()); }
		(rule__AttributeFillerUnsignedDoubleRandom__Group__0)
		{ after(grammarAccess.getAttributeFillerUnsignedDoubleRandomAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerUnsignedIntegerRange
entryRuleAttributeFillerUnsignedIntegerRange
:
{ before(grammarAccess.getAttributeFillerUnsignedIntegerRangeRule()); }
	 ruleAttributeFillerUnsignedIntegerRange
{ after(grammarAccess.getAttributeFillerUnsignedIntegerRangeRule()); } 
	 EOF 
;

// Rule AttributeFillerUnsignedIntegerRange
ruleAttributeFillerUnsignedIntegerRange 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerUnsignedIntegerRangeAccess().getGroup()); }
		(rule__AttributeFillerUnsignedIntegerRange__Group__0)
		{ after(grammarAccess.getAttributeFillerUnsignedIntegerRangeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttributeFillerUnsignedIntegerRandom
entryRuleAttributeFillerUnsignedIntegerRandom
:
{ before(grammarAccess.getAttributeFillerUnsignedIntegerRandomRule()); }
	 ruleAttributeFillerUnsignedIntegerRandom
{ after(grammarAccess.getAttributeFillerUnsignedIntegerRandomRule()); } 
	 EOF 
;

// Rule AttributeFillerUnsignedIntegerRandom
ruleAttributeFillerUnsignedIntegerRandom 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeFillerUnsignedIntegerRandomAccess().getGroup()); }
		(rule__AttributeFillerUnsignedIntegerRandom__Group__0)
		{ after(grammarAccess.getAttributeFillerUnsignedIntegerRandomAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleSignedNumber
entryRuleSignedNumber
:
{ before(grammarAccess.getSignedNumberRule()); }
	 ruleSignedNumber
{ after(grammarAccess.getSignedNumberRule()); } 
	 EOF 
;

// Rule SignedNumber
ruleSignedNumber 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getSignedNumberAccess().getGroup()); }
		(rule__SignedNumber__Group__0)
		{ after(grammarAccess.getSignedNumberAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleUnsignedNumber
entryRuleUnsignedNumber
:
{ before(grammarAccess.getUnsignedNumberRule()); }
	 ruleUnsignedNumber
{ after(grammarAccess.getUnsignedNumberRule()); } 
	 EOF 
;

// Rule UnsignedNumber
ruleUnsignedNumber 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getUnsignedNumberAccess().getGroup()); }
		(rule__UnsignedNumber__Group__0)
		{ after(grammarAccess.getUnsignedNumberAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleSINT
entryRuleSINT
:
{ before(grammarAccess.getSINTRule()); }
	 ruleSINT
{ after(grammarAccess.getSINTRule()); } 
	 EOF 
;

// Rule SINT
ruleSINT 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getSINTAccess().getGroup()); }
		(rule__SINT__Group__0)
		{ after(grammarAccess.getSINTAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXImportDeclaration
entryRuleXImportDeclaration
:
{ before(grammarAccess.getXImportDeclarationRule()); }
	 ruleXImportDeclaration
{ after(grammarAccess.getXImportDeclarationRule()); } 
	 EOF 
;

// Rule XImportDeclaration
ruleXImportDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXImportDeclarationAccess().getGroup()); }
		(rule__XImportDeclaration__Group__0)
		{ after(grammarAccess.getXImportDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXAnnotation
entryRuleXAnnotation
:
{ before(grammarAccess.getXAnnotationRule()); }
	 ruleXAnnotation
{ after(grammarAccess.getXAnnotationRule()); } 
	 EOF 
;

// Rule XAnnotation
ruleXAnnotation 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXAnnotationAccess().getGroup()); }
		(rule__XAnnotation__Group__0)
		{ after(grammarAccess.getXAnnotationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXAnnotationElementValuePair
entryRuleXAnnotationElementValuePair
:
{ before(grammarAccess.getXAnnotationElementValuePairRule()); }
	 ruleXAnnotationElementValuePair
{ after(grammarAccess.getXAnnotationElementValuePairRule()); } 
	 EOF 
;

// Rule XAnnotationElementValuePair
ruleXAnnotationElementValuePair 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup()); }
		(rule__XAnnotationElementValuePair__Group__0)
		{ after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXAnnotationElementValueOrCommaList
entryRuleXAnnotationElementValueOrCommaList
:
{ before(grammarAccess.getXAnnotationElementValueOrCommaListRule()); }
	 ruleXAnnotationElementValueOrCommaList
{ after(grammarAccess.getXAnnotationElementValueOrCommaListRule()); } 
	 EOF 
;

// Rule XAnnotationElementValueOrCommaList
ruleXAnnotationElementValueOrCommaList 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives()); }
		(rule__XAnnotationElementValueOrCommaList__Alternatives)
		{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXAnnotationElementValue
entryRuleXAnnotationElementValue
:
{ before(grammarAccess.getXAnnotationElementValueRule()); }
	 ruleXAnnotationElementValue
{ after(grammarAccess.getXAnnotationElementValueRule()); } 
	 EOF 
;

// Rule XAnnotationElementValue
ruleXAnnotationElementValue 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXAnnotationElementValueAccess().getAlternatives()); }
		(rule__XAnnotationElementValue__Alternatives)
		{ after(grammarAccess.getXAnnotationElementValueAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXAnnotationOrExpression
entryRuleXAnnotationOrExpression
:
{ before(grammarAccess.getXAnnotationOrExpressionRule()); }
	 ruleXAnnotationOrExpression
{ after(grammarAccess.getXAnnotationOrExpressionRule()); } 
	 EOF 
;

// Rule XAnnotationOrExpression
ruleXAnnotationOrExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives()); }
		(rule__XAnnotationOrExpression__Alternatives)
		{ after(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXExpression
entryRuleXExpression
:
{ before(grammarAccess.getXExpressionRule()); }
	 ruleXExpression
{ after(grammarAccess.getXExpressionRule()); } 
	 EOF 
;

// Rule XExpression
ruleXExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); }
		ruleXAssignment
		{ after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXAssignment
entryRuleXAssignment
:
{ before(grammarAccess.getXAssignmentRule()); }
	 ruleXAssignment
{ after(grammarAccess.getXAssignmentRule()); } 
	 EOF 
;

// Rule XAssignment
ruleXAssignment 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXAssignmentAccess().getAlternatives()); }
		(rule__XAssignment__Alternatives)
		{ after(grammarAccess.getXAssignmentAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleOpSingleAssign
entryRuleOpSingleAssign
:
{ before(grammarAccess.getOpSingleAssignRule()); }
	 ruleOpSingleAssign
{ after(grammarAccess.getOpSingleAssignRule()); } 
	 EOF 
;

// Rule OpSingleAssign
ruleOpSingleAssign 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); }
		'='
		{ after(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleOpMultiAssign
entryRuleOpMultiAssign
:
{ before(grammarAccess.getOpMultiAssignRule()); }
	 ruleOpMultiAssign
{ after(grammarAccess.getOpMultiAssignRule()); } 
	 EOF 
;

// Rule OpMultiAssign
ruleOpMultiAssign 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getOpMultiAssignAccess().getAlternatives()); }
		(rule__OpMultiAssign__Alternatives)
		{ after(grammarAccess.getOpMultiAssignAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXOrExpression
entryRuleXOrExpression
:
{ before(grammarAccess.getXOrExpressionRule()); }
	 ruleXOrExpression
{ after(grammarAccess.getXOrExpressionRule()); } 
	 EOF 
;

// Rule XOrExpression
ruleXOrExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXOrExpressionAccess().getGroup()); }
		(rule__XOrExpression__Group__0)
		{ after(grammarAccess.getXOrExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleOpOr
entryRuleOpOr
:
{ before(grammarAccess.getOpOrRule()); }
	 ruleOpOr
{ after(grammarAccess.getOpOrRule()); } 
	 EOF 
;

// Rule OpOr
ruleOpOr 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); }
		'||'
		{ after(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXAndExpression
entryRuleXAndExpression
:
{ before(grammarAccess.getXAndExpressionRule()); }
	 ruleXAndExpression
{ after(grammarAccess.getXAndExpressionRule()); } 
	 EOF 
;

// Rule XAndExpression
ruleXAndExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXAndExpressionAccess().getGroup()); }
		(rule__XAndExpression__Group__0)
		{ after(grammarAccess.getXAndExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleOpAnd
entryRuleOpAnd
:
{ before(grammarAccess.getOpAndRule()); }
	 ruleOpAnd
{ after(grammarAccess.getOpAndRule()); } 
	 EOF 
;

// Rule OpAnd
ruleOpAnd 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); }
		'&&'
		{ after(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXEqualityExpression
entryRuleXEqualityExpression
:
{ before(grammarAccess.getXEqualityExpressionRule()); }
	 ruleXEqualityExpression
{ after(grammarAccess.getXEqualityExpressionRule()); } 
	 EOF 
;

// Rule XEqualityExpression
ruleXEqualityExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXEqualityExpressionAccess().getGroup()); }
		(rule__XEqualityExpression__Group__0)
		{ after(grammarAccess.getXEqualityExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleOpEquality
entryRuleOpEquality
:
{ before(grammarAccess.getOpEqualityRule()); }
	 ruleOpEquality
{ after(grammarAccess.getOpEqualityRule()); } 
	 EOF 
;

// Rule OpEquality
ruleOpEquality 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getOpEqualityAccess().getAlternatives()); }
		(rule__OpEquality__Alternatives)
		{ after(grammarAccess.getOpEqualityAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXRelationalExpression
entryRuleXRelationalExpression
:
{ before(grammarAccess.getXRelationalExpressionRule()); }
	 ruleXRelationalExpression
{ after(grammarAccess.getXRelationalExpressionRule()); } 
	 EOF 
;

// Rule XRelationalExpression
ruleXRelationalExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXRelationalExpressionAccess().getGroup()); }
		(rule__XRelationalExpression__Group__0)
		{ after(grammarAccess.getXRelationalExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleOpCompare
entryRuleOpCompare
:
{ before(grammarAccess.getOpCompareRule()); }
	 ruleOpCompare
{ after(grammarAccess.getOpCompareRule()); } 
	 EOF 
;

// Rule OpCompare
ruleOpCompare 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getOpCompareAccess().getAlternatives()); }
		(rule__OpCompare__Alternatives)
		{ after(grammarAccess.getOpCompareAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXOtherOperatorExpression
entryRuleXOtherOperatorExpression
:
{ before(grammarAccess.getXOtherOperatorExpressionRule()); }
	 ruleXOtherOperatorExpression
{ after(grammarAccess.getXOtherOperatorExpressionRule()); } 
	 EOF 
;

// Rule XOtherOperatorExpression
ruleXOtherOperatorExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); }
		(rule__XOtherOperatorExpression__Group__0)
		{ after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleOpOther
entryRuleOpOther
:
{ before(grammarAccess.getOpOtherRule()); }
	 ruleOpOther
{ after(grammarAccess.getOpOtherRule()); } 
	 EOF 
;

// Rule OpOther
ruleOpOther 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getOpOtherAccess().getAlternatives()); }
		(rule__OpOther__Alternatives)
		{ after(grammarAccess.getOpOtherAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXAdditiveExpression
entryRuleXAdditiveExpression
:
{ before(grammarAccess.getXAdditiveExpressionRule()); }
	 ruleXAdditiveExpression
{ after(grammarAccess.getXAdditiveExpressionRule()); } 
	 EOF 
;

// Rule XAdditiveExpression
ruleXAdditiveExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXAdditiveExpressionAccess().getGroup()); }
		(rule__XAdditiveExpression__Group__0)
		{ after(grammarAccess.getXAdditiveExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleOpAdd
entryRuleOpAdd
:
{ before(grammarAccess.getOpAddRule()); }
	 ruleOpAdd
{ after(grammarAccess.getOpAddRule()); } 
	 EOF 
;

// Rule OpAdd
ruleOpAdd 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getOpAddAccess().getAlternatives()); }
		(rule__OpAdd__Alternatives)
		{ after(grammarAccess.getOpAddAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXMultiplicativeExpression
entryRuleXMultiplicativeExpression
:
{ before(grammarAccess.getXMultiplicativeExpressionRule()); }
	 ruleXMultiplicativeExpression
{ after(grammarAccess.getXMultiplicativeExpressionRule()); } 
	 EOF 
;

// Rule XMultiplicativeExpression
ruleXMultiplicativeExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); }
		(rule__XMultiplicativeExpression__Group__0)
		{ after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleOpMulti
entryRuleOpMulti
:
{ before(grammarAccess.getOpMultiRule()); }
	 ruleOpMulti
{ after(grammarAccess.getOpMultiRule()); } 
	 EOF 
;

// Rule OpMulti
ruleOpMulti 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getOpMultiAccess().getAlternatives()); }
		(rule__OpMulti__Alternatives)
		{ after(grammarAccess.getOpMultiAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXUnaryOperation
entryRuleXUnaryOperation
:
{ before(grammarAccess.getXUnaryOperationRule()); }
	 ruleXUnaryOperation
{ after(grammarAccess.getXUnaryOperationRule()); } 
	 EOF 
;

// Rule XUnaryOperation
ruleXUnaryOperation 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXUnaryOperationAccess().getAlternatives()); }
		(rule__XUnaryOperation__Alternatives)
		{ after(grammarAccess.getXUnaryOperationAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleOpUnary
entryRuleOpUnary
:
{ before(grammarAccess.getOpUnaryRule()); }
	 ruleOpUnary
{ after(grammarAccess.getOpUnaryRule()); } 
	 EOF 
;

// Rule OpUnary
ruleOpUnary 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getOpUnaryAccess().getAlternatives()); }
		(rule__OpUnary__Alternatives)
		{ after(grammarAccess.getOpUnaryAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXCastedExpression
entryRuleXCastedExpression
:
{ before(grammarAccess.getXCastedExpressionRule()); }
	 ruleXCastedExpression
{ after(grammarAccess.getXCastedExpressionRule()); } 
	 EOF 
;

// Rule XCastedExpression
ruleXCastedExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXCastedExpressionAccess().getGroup()); }
		(rule__XCastedExpression__Group__0)
		{ after(grammarAccess.getXCastedExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXPostfixOperation
entryRuleXPostfixOperation
:
{ before(grammarAccess.getXPostfixOperationRule()); }
	 ruleXPostfixOperation
{ after(grammarAccess.getXPostfixOperationRule()); } 
	 EOF 
;

// Rule XPostfixOperation
ruleXPostfixOperation 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXPostfixOperationAccess().getGroup()); }
		(rule__XPostfixOperation__Group__0)
		{ after(grammarAccess.getXPostfixOperationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleOpPostfix
entryRuleOpPostfix
:
{ before(grammarAccess.getOpPostfixRule()); }
	 ruleOpPostfix
{ after(grammarAccess.getOpPostfixRule()); } 
	 EOF 
;

// Rule OpPostfix
ruleOpPostfix 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getOpPostfixAccess().getAlternatives()); }
		(rule__OpPostfix__Alternatives)
		{ after(grammarAccess.getOpPostfixAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXMemberFeatureCall
entryRuleXMemberFeatureCall
:
{ before(grammarAccess.getXMemberFeatureCallRule()); }
	 ruleXMemberFeatureCall
{ after(grammarAccess.getXMemberFeatureCallRule()); } 
	 EOF 
;

// Rule XMemberFeatureCall
ruleXMemberFeatureCall 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup()); }
		(rule__XMemberFeatureCall__Group__0)
		{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXPrimaryExpression
entryRuleXPrimaryExpression
:
{ before(grammarAccess.getXPrimaryExpressionRule()); }
	 ruleXPrimaryExpression
{ after(grammarAccess.getXPrimaryExpressionRule()); } 
	 EOF 
;

// Rule XPrimaryExpression
ruleXPrimaryExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); }
		(rule__XPrimaryExpression__Alternatives)
		{ after(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXLiteral
entryRuleXLiteral
:
{ before(grammarAccess.getXLiteralRule()); }
	 ruleXLiteral
{ after(grammarAccess.getXLiteralRule()); } 
	 EOF 
;

// Rule XLiteral
ruleXLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXLiteralAccess().getAlternatives()); }
		(rule__XLiteral__Alternatives)
		{ after(grammarAccess.getXLiteralAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXCollectionLiteral
entryRuleXCollectionLiteral
:
{ before(grammarAccess.getXCollectionLiteralRule()); }
	 ruleXCollectionLiteral
{ after(grammarAccess.getXCollectionLiteralRule()); } 
	 EOF 
;

// Rule XCollectionLiteral
ruleXCollectionLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); }
		(rule__XCollectionLiteral__Alternatives)
		{ after(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXSetLiteral
entryRuleXSetLiteral
:
{ before(grammarAccess.getXSetLiteralRule()); }
	 ruleXSetLiteral
{ after(grammarAccess.getXSetLiteralRule()); } 
	 EOF 
;

// Rule XSetLiteral
ruleXSetLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXSetLiteralAccess().getGroup()); }
		(rule__XSetLiteral__Group__0)
		{ after(grammarAccess.getXSetLiteralAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXListLiteral
entryRuleXListLiteral
:
{ before(grammarAccess.getXListLiteralRule()); }
	 ruleXListLiteral
{ after(grammarAccess.getXListLiteralRule()); } 
	 EOF 
;

// Rule XListLiteral
ruleXListLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXListLiteralAccess().getGroup()); }
		(rule__XListLiteral__Group__0)
		{ after(grammarAccess.getXListLiteralAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXClosure
entryRuleXClosure
:
{ before(grammarAccess.getXClosureRule()); }
	 ruleXClosure
{ after(grammarAccess.getXClosureRule()); } 
	 EOF 
;

// Rule XClosure
ruleXClosure 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXClosureAccess().getGroup()); }
		(rule__XClosure__Group__0)
		{ after(grammarAccess.getXClosureAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXExpressionInClosure
entryRuleXExpressionInClosure
:
{ before(grammarAccess.getXExpressionInClosureRule()); }
	 ruleXExpressionInClosure
{ after(grammarAccess.getXExpressionInClosureRule()); } 
	 EOF 
;

// Rule XExpressionInClosure
ruleXExpressionInClosure 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXExpressionInClosureAccess().getGroup()); }
		(rule__XExpressionInClosure__Group__0)
		{ after(grammarAccess.getXExpressionInClosureAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXShortClosure
entryRuleXShortClosure
:
{ before(grammarAccess.getXShortClosureRule()); }
	 ruleXShortClosure
{ after(grammarAccess.getXShortClosureRule()); } 
	 EOF 
;

// Rule XShortClosure
ruleXShortClosure 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXShortClosureAccess().getGroup()); }
		(rule__XShortClosure__Group__0)
		{ after(grammarAccess.getXShortClosureAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXParenthesizedExpression
entryRuleXParenthesizedExpression
:
{ before(grammarAccess.getXParenthesizedExpressionRule()); }
	 ruleXParenthesizedExpression
{ after(grammarAccess.getXParenthesizedExpressionRule()); } 
	 EOF 
;

// Rule XParenthesizedExpression
ruleXParenthesizedExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); }
		(rule__XParenthesizedExpression__Group__0)
		{ after(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXIfExpression
entryRuleXIfExpression
:
{ before(grammarAccess.getXIfExpressionRule()); }
	 ruleXIfExpression
{ after(grammarAccess.getXIfExpressionRule()); } 
	 EOF 
;

// Rule XIfExpression
ruleXIfExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXIfExpressionAccess().getGroup()); }
		(rule__XIfExpression__Group__0)
		{ after(grammarAccess.getXIfExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXSwitchExpression
entryRuleXSwitchExpression
:
{ before(grammarAccess.getXSwitchExpressionRule()); }
	 ruleXSwitchExpression
{ after(grammarAccess.getXSwitchExpressionRule()); } 
	 EOF 
;

// Rule XSwitchExpression
ruleXSwitchExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXSwitchExpressionAccess().getGroup()); }
		(rule__XSwitchExpression__Group__0)
		{ after(grammarAccess.getXSwitchExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXCasePart
entryRuleXCasePart
:
{ before(grammarAccess.getXCasePartRule()); }
	 ruleXCasePart
{ after(grammarAccess.getXCasePartRule()); } 
	 EOF 
;

// Rule XCasePart
ruleXCasePart 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXCasePartAccess().getGroup()); }
		(rule__XCasePart__Group__0)
		{ after(grammarAccess.getXCasePartAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXForLoopExpression
entryRuleXForLoopExpression
:
{ before(grammarAccess.getXForLoopExpressionRule()); }
	 ruleXForLoopExpression
{ after(grammarAccess.getXForLoopExpressionRule()); } 
	 EOF 
;

// Rule XForLoopExpression
ruleXForLoopExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXForLoopExpressionAccess().getGroup()); }
		(rule__XForLoopExpression__Group__0)
		{ after(grammarAccess.getXForLoopExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXBasicForLoopExpression
entryRuleXBasicForLoopExpression
:
{ before(grammarAccess.getXBasicForLoopExpressionRule()); }
	 ruleXBasicForLoopExpression
{ after(grammarAccess.getXBasicForLoopExpressionRule()); } 
	 EOF 
;

// Rule XBasicForLoopExpression
ruleXBasicForLoopExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); }
		(rule__XBasicForLoopExpression__Group__0)
		{ after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXWhileExpression
entryRuleXWhileExpression
:
{ before(grammarAccess.getXWhileExpressionRule()); }
	 ruleXWhileExpression
{ after(grammarAccess.getXWhileExpressionRule()); } 
	 EOF 
;

// Rule XWhileExpression
ruleXWhileExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXWhileExpressionAccess().getGroup()); }
		(rule__XWhileExpression__Group__0)
		{ after(grammarAccess.getXWhileExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXDoWhileExpression
entryRuleXDoWhileExpression
:
{ before(grammarAccess.getXDoWhileExpressionRule()); }
	 ruleXDoWhileExpression
{ after(grammarAccess.getXDoWhileExpressionRule()); } 
	 EOF 
;

// Rule XDoWhileExpression
ruleXDoWhileExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXDoWhileExpressionAccess().getGroup()); }
		(rule__XDoWhileExpression__Group__0)
		{ after(grammarAccess.getXDoWhileExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXBlockExpression
entryRuleXBlockExpression
:
{ before(grammarAccess.getXBlockExpressionRule()); }
	 ruleXBlockExpression
{ after(grammarAccess.getXBlockExpressionRule()); } 
	 EOF 
;

// Rule XBlockExpression
ruleXBlockExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXBlockExpressionAccess().getGroup()); }
		(rule__XBlockExpression__Group__0)
		{ after(grammarAccess.getXBlockExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXExpressionOrVarDeclaration
entryRuleXExpressionOrVarDeclaration
:
{ before(grammarAccess.getXExpressionOrVarDeclarationRule()); }
	 ruleXExpressionOrVarDeclaration
{ after(grammarAccess.getXExpressionOrVarDeclarationRule()); } 
	 EOF 
;

// Rule XExpressionOrVarDeclaration
ruleXExpressionOrVarDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); }
		(rule__XExpressionOrVarDeclaration__Alternatives)
		{ after(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXVariableDeclaration
entryRuleXVariableDeclaration
:
{ before(grammarAccess.getXVariableDeclarationRule()); }
	 ruleXVariableDeclaration
{ after(grammarAccess.getXVariableDeclarationRule()); } 
	 EOF 
;

// Rule XVariableDeclaration
ruleXVariableDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXVariableDeclarationAccess().getGroup()); }
		(rule__XVariableDeclaration__Group__0)
		{ after(grammarAccess.getXVariableDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleJvmFormalParameter
entryRuleJvmFormalParameter
:
{ before(grammarAccess.getJvmFormalParameterRule()); }
	 ruleJvmFormalParameter
{ after(grammarAccess.getJvmFormalParameterRule()); } 
	 EOF 
;

// Rule JvmFormalParameter
ruleJvmFormalParameter 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getJvmFormalParameterAccess().getGroup()); }
		(rule__JvmFormalParameter__Group__0)
		{ after(grammarAccess.getJvmFormalParameterAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleFullJvmFormalParameter
entryRuleFullJvmFormalParameter
:
{ before(grammarAccess.getFullJvmFormalParameterRule()); }
	 ruleFullJvmFormalParameter
{ after(grammarAccess.getFullJvmFormalParameterRule()); } 
	 EOF 
;

// Rule FullJvmFormalParameter
ruleFullJvmFormalParameter 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); }
		(rule__FullJvmFormalParameter__Group__0)
		{ after(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXFeatureCall
entryRuleXFeatureCall
:
{ before(grammarAccess.getXFeatureCallRule()); }
	 ruleXFeatureCall
{ after(grammarAccess.getXFeatureCallRule()); } 
	 EOF 
;

// Rule XFeatureCall
ruleXFeatureCall 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXFeatureCallAccess().getGroup()); }
		(rule__XFeatureCall__Group__0)
		{ after(grammarAccess.getXFeatureCallAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleFeatureCallID
entryRuleFeatureCallID
:
{ before(grammarAccess.getFeatureCallIDRule()); }
	 ruleFeatureCallID
{ after(grammarAccess.getFeatureCallIDRule()); } 
	 EOF 
;

// Rule FeatureCallID
ruleFeatureCallID 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getFeatureCallIDAccess().getAlternatives()); }
		(rule__FeatureCallID__Alternatives)
		{ after(grammarAccess.getFeatureCallIDAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleIdOrSuper
entryRuleIdOrSuper
:
{ before(grammarAccess.getIdOrSuperRule()); }
	 ruleIdOrSuper
{ after(grammarAccess.getIdOrSuperRule()); } 
	 EOF 
;

// Rule IdOrSuper
ruleIdOrSuper 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getIdOrSuperAccess().getAlternatives()); }
		(rule__IdOrSuper__Alternatives)
		{ after(grammarAccess.getIdOrSuperAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXConstructorCall
entryRuleXConstructorCall
:
{ before(grammarAccess.getXConstructorCallRule()); }
	 ruleXConstructorCall
{ after(grammarAccess.getXConstructorCallRule()); } 
	 EOF 
;

// Rule XConstructorCall
ruleXConstructorCall 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXConstructorCallAccess().getGroup()); }
		(rule__XConstructorCall__Group__0)
		{ after(grammarAccess.getXConstructorCallAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXBooleanLiteral
entryRuleXBooleanLiteral
:
{ before(grammarAccess.getXBooleanLiteralRule()); }
	 ruleXBooleanLiteral
{ after(grammarAccess.getXBooleanLiteralRule()); } 
	 EOF 
;

// Rule XBooleanLiteral
ruleXBooleanLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXBooleanLiteralAccess().getGroup()); }
		(rule__XBooleanLiteral__Group__0)
		{ after(grammarAccess.getXBooleanLiteralAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXNullLiteral
entryRuleXNullLiteral
:
{ before(grammarAccess.getXNullLiteralRule()); }
	 ruleXNullLiteral
{ after(grammarAccess.getXNullLiteralRule()); } 
	 EOF 
;

// Rule XNullLiteral
ruleXNullLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXNullLiteralAccess().getGroup()); }
		(rule__XNullLiteral__Group__0)
		{ after(grammarAccess.getXNullLiteralAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXNumberLiteral
entryRuleXNumberLiteral
:
{ before(grammarAccess.getXNumberLiteralRule()); }
	 ruleXNumberLiteral
{ after(grammarAccess.getXNumberLiteralRule()); } 
	 EOF 
;

// Rule XNumberLiteral
ruleXNumberLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXNumberLiteralAccess().getGroup()); }
		(rule__XNumberLiteral__Group__0)
		{ after(grammarAccess.getXNumberLiteralAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXStringLiteral
entryRuleXStringLiteral
:
{ before(grammarAccess.getXStringLiteralRule()); }
	 ruleXStringLiteral
{ after(grammarAccess.getXStringLiteralRule()); } 
	 EOF 
;

// Rule XStringLiteral
ruleXStringLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXStringLiteralAccess().getGroup()); }
		(rule__XStringLiteral__Group__0)
		{ after(grammarAccess.getXStringLiteralAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXTypeLiteral
entryRuleXTypeLiteral
:
{ before(grammarAccess.getXTypeLiteralRule()); }
	 ruleXTypeLiteral
{ after(grammarAccess.getXTypeLiteralRule()); } 
	 EOF 
;

// Rule XTypeLiteral
ruleXTypeLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXTypeLiteralAccess().getGroup()); }
		(rule__XTypeLiteral__Group__0)
		{ after(grammarAccess.getXTypeLiteralAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXThrowExpression
entryRuleXThrowExpression
:
{ before(grammarAccess.getXThrowExpressionRule()); }
	 ruleXThrowExpression
{ after(grammarAccess.getXThrowExpressionRule()); } 
	 EOF 
;

// Rule XThrowExpression
ruleXThrowExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXThrowExpressionAccess().getGroup()); }
		(rule__XThrowExpression__Group__0)
		{ after(grammarAccess.getXThrowExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXReturnExpression
entryRuleXReturnExpression
:
{ before(grammarAccess.getXReturnExpressionRule()); }
	 ruleXReturnExpression
{ after(grammarAccess.getXReturnExpressionRule()); } 
	 EOF 
;

// Rule XReturnExpression
ruleXReturnExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXReturnExpressionAccess().getGroup()); }
		(rule__XReturnExpression__Group__0)
		{ after(grammarAccess.getXReturnExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXTryCatchFinallyExpression
entryRuleXTryCatchFinallyExpression
:
{ before(grammarAccess.getXTryCatchFinallyExpressionRule()); }
	 ruleXTryCatchFinallyExpression
{ after(grammarAccess.getXTryCatchFinallyExpressionRule()); } 
	 EOF 
;

// Rule XTryCatchFinallyExpression
ruleXTryCatchFinallyExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); }
		(rule__XTryCatchFinallyExpression__Group__0)
		{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXSynchronizedExpression
entryRuleXSynchronizedExpression
:
{ before(grammarAccess.getXSynchronizedExpressionRule()); }
	 ruleXSynchronizedExpression
{ after(grammarAccess.getXSynchronizedExpressionRule()); } 
	 EOF 
;

// Rule XSynchronizedExpression
ruleXSynchronizedExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); }
		(rule__XSynchronizedExpression__Group__0)
		{ after(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXCatchClause
entryRuleXCatchClause
:
{ before(grammarAccess.getXCatchClauseRule()); }
	 ruleXCatchClause
{ after(grammarAccess.getXCatchClauseRule()); } 
	 EOF 
;

// Rule XCatchClause
ruleXCatchClause 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXCatchClauseAccess().getGroup()); }
		(rule__XCatchClause__Group__0)
		{ after(grammarAccess.getXCatchClauseAccess().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 entryRuleNumber
entryRuleNumber
@init { 
	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
}
:
{ before(grammarAccess.getNumberRule()); }
	 ruleNumber
{ after(grammarAccess.getNumberRule()); } 
	 EOF 
;
finally {
	myHiddenTokenState.restore();
}

// Rule Number
ruleNumber 
	@init {
		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getNumberAccess().getAlternatives()); }
		(rule__Number__Alternatives)
		{ after(grammarAccess.getNumberAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
	myHiddenTokenState.restore();
}

// Entry rule entryRuleJvmTypeReference
entryRuleJvmTypeReference
:
{ before(grammarAccess.getJvmTypeReferenceRule()); }
	 ruleJvmTypeReference
{ after(grammarAccess.getJvmTypeReferenceRule()); } 
	 EOF 
;

// Rule JvmTypeReference
ruleJvmTypeReference 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); }
		(rule__JvmTypeReference__Alternatives)
		{ after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleArrayBrackets
entryRuleArrayBrackets
:
{ before(grammarAccess.getArrayBracketsRule()); }
	 ruleArrayBrackets
{ after(grammarAccess.getArrayBracketsRule()); } 
	 EOF 
;

// Rule ArrayBrackets
ruleArrayBrackets 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getArrayBracketsAccess().getGroup()); }
		(rule__ArrayBrackets__Group__0)
		{ after(grammarAccess.getArrayBracketsAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleXFunctionTypeRef
entryRuleXFunctionTypeRef
:
{ before(grammarAccess.getXFunctionTypeRefRule()); }
	 ruleXFunctionTypeRef
{ after(grammarAccess.getXFunctionTypeRefRule()); } 
	 EOF 
;

// Rule XFunctionTypeRef
ruleXFunctionTypeRef 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); }
		(rule__XFunctionTypeRef__Group__0)
		{ after(grammarAccess.getXFunctionTypeRefAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleJvmParameterizedTypeReference
entryRuleJvmParameterizedTypeReference
:
{ before(grammarAccess.getJvmParameterizedTypeReferenceRule()); }
	 ruleJvmParameterizedTypeReference
{ after(grammarAccess.getJvmParameterizedTypeReferenceRule()); } 
	 EOF 
;

// Rule JvmParameterizedTypeReference
ruleJvmParameterizedTypeReference 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); }
		(rule__JvmParameterizedTypeReference__Group__0)
		{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); }
	)
;