org.eclipse.osbp.xtext.functionlibrarydsl.ui/src-gen/org/eclipse/osbp/xtext/functionlibrarydsl/ui/contentassist/antlr/internal/InternalFunctionLibraryDsl.g - osbp/org.eclipse.osbp.xtext.functionlibrary - Git at Google

 /**
  *
  *  Copyright (c) 2011, 2016 - 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
  *
  */

 grammar InternalFunctionLibraryDsl;

 options {
 	superClass=AbstractInternalContentAssistParser;
 	backtrack=true;

 }

 @lexer::header {
 package org.eclipse.osbp.xtext.functionlibrarydsl.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.eclipse.osbp.xtext.functionlibrarydsl.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.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.eclipse.osbp.xtext.functionlibrarydsl.services.FunctionLibraryDslGrammarAccess;

 }

 @parser::members {

  	private FunctionLibraryDslGrammarAccess grammarAccess;

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

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

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

 }


 // Entry rule entryRuleFunctionLibraryModel
 entryRuleFunctionLibraryModel
 :
 { before(grammarAccess.getFunctionLibraryModelRule()); }
 	 ruleFunctionLibraryModel
 { after(grammarAccess.getFunctionLibraryModelRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryModel
 ruleFunctionLibraryModel
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryModelAccess().getPckgAssignment()); }
 (rule__FunctionLibraryModel__PckgAssignment)
 { after(grammarAccess.getFunctionLibraryModelAccess().getPckgAssignment()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionLibraryPackage
 entryRuleFunctionLibraryPackage
 :
 { before(grammarAccess.getFunctionLibraryPackageRule()); }
 	 ruleFunctionLibraryPackage
 { after(grammarAccess.getFunctionLibraryPackageRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryPackage
 ruleFunctionLibraryPackage
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryPackageAccess().getGroup()); }
 (rule__FunctionLibraryPackage__Group__0)
 { after(grammarAccess.getFunctionLibraryPackageAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionLibraryGroup
 entryRuleFunctionLibraryGroup
 :
 { before(grammarAccess.getFunctionLibraryGroupRule()); }
 	 ruleFunctionLibraryGroup
 { after(grammarAccess.getFunctionLibraryGroupRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryGroup
 ruleFunctionLibraryGroup
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryGroupAccess().getGroup()); }
 (rule__FunctionLibraryGroup__Group__0)
 { after(grammarAccess.getFunctionLibraryGroupAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionLibraryBlipGroup
 entryRuleFunctionLibraryBlipGroup
 :
 { before(grammarAccess.getFunctionLibraryBlipGroupRule()); }
 	 ruleFunctionLibraryBlipGroup
 { after(grammarAccess.getFunctionLibraryBlipGroupRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryBlipGroup
 ruleFunctionLibraryBlipGroup
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryBlipGroupAccess().getGroup()); }
 (rule__FunctionLibraryBlipGroup__Group__0)
 { after(grammarAccess.getFunctionLibraryBlipGroupAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionLibraryStatemachineGroup
 entryRuleFunctionLibraryStatemachineGroup
 :
 { before(grammarAccess.getFunctionLibraryStatemachineGroupRule()); }
 	 ruleFunctionLibraryStatemachineGroup
 { after(grammarAccess.getFunctionLibraryStatemachineGroupRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryStatemachineGroup
 ruleFunctionLibraryStatemachineGroup
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryStatemachineGroupAccess().getGroup()); }
 (rule__FunctionLibraryStatemachineGroup__Group__0)
 { after(grammarAccess.getFunctionLibraryStatemachineGroupAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionLibraryConverterGroup
 entryRuleFunctionLibraryConverterGroup
 :
 { before(grammarAccess.getFunctionLibraryConverterGroupRule()); }
 	 ruleFunctionLibraryConverterGroup
 { after(grammarAccess.getFunctionLibraryConverterGroupRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryConverterGroup
 ruleFunctionLibraryConverterGroup
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryConverterGroupAccess().getGroup()); }
 (rule__FunctionLibraryConverterGroup__Group__0)
 { after(grammarAccess.getFunctionLibraryConverterGroupAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionConvertToModel
 entryRuleFunctionConvertToModel
 :
 { before(grammarAccess.getFunctionConvertToModelRule()); }
 	 ruleFunctionConvertToModel
 { after(grammarAccess.getFunctionConvertToModelRule()); }
 	 EOF
 ;

 // Rule FunctionConvertToModel
 ruleFunctionConvertToModel
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionConvertToModelAccess().getGroup()); }
 (rule__FunctionConvertToModel__Group__0)
 { after(grammarAccess.getFunctionConvertToModelAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionConvertToPresentation
 entryRuleFunctionConvertToPresentation
 :
 { before(grammarAccess.getFunctionConvertToPresentationRule()); }
 	 ruleFunctionConvertToPresentation
 { after(grammarAccess.getFunctionConvertToPresentationRule()); }
 	 EOF
 ;

 // Rule FunctionConvertToPresentation
 ruleFunctionConvertToPresentation
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionConvertToPresentationAccess().getGroup()); }
 (rule__FunctionConvertToPresentation__Group__0)
 { after(grammarAccess.getFunctionConvertToPresentationAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionLibraryRating
 entryRuleFunctionLibraryRating
 :
 { before(grammarAccess.getFunctionLibraryRatingRule()); }
 	 ruleFunctionLibraryRating
 { after(grammarAccess.getFunctionLibraryRatingRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryRating
 ruleFunctionLibraryRating
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryRatingAccess().getGroup()); }
 (rule__FunctionLibraryRating__Group__0)
 { after(grammarAccess.getFunctionLibraryRatingAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionLibraryRatingItem
 entryRuleFunctionLibraryRatingItem
 :
 { before(grammarAccess.getFunctionLibraryRatingItemRule()); }
 	 ruleFunctionLibraryRatingItem
 { after(grammarAccess.getFunctionLibraryRatingItemRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryRatingItem
 ruleFunctionLibraryRatingItem
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryRatingItemAccess().getNameAssignment()); }
 (rule__FunctionLibraryRatingItem__NameAssignment)
 { after(grammarAccess.getFunctionLibraryRatingItemAccess().getNameAssignment()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionLibraryFunction
 entryRuleFunctionLibraryFunction
 :
 { before(grammarAccess.getFunctionLibraryFunctionRule()); }
 	 ruleFunctionLibraryFunction
 { after(grammarAccess.getFunctionLibraryFunctionRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryFunction
 ruleFunctionLibraryFunction
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryFunctionAccess().getGroup()); }
 (rule__FunctionLibraryFunction__Group__0)
 { after(grammarAccess.getFunctionLibraryFunctionAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionLibraryTest
 entryRuleFunctionLibraryTest
 :
 { before(grammarAccess.getFunctionLibraryTestRule()); }
 	 ruleFunctionLibraryTest
 { after(grammarAccess.getFunctionLibraryTestRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryTest
 ruleFunctionLibraryTest
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryTestAccess().getGroup()); }
 (rule__FunctionLibraryTest__Group__0)
 { after(grammarAccess.getFunctionLibraryTestAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionLibraryRate
 entryRuleFunctionLibraryRate
 :
 { before(grammarAccess.getFunctionLibraryRateRule()); }
 	 ruleFunctionLibraryRate
 { after(grammarAccess.getFunctionLibraryRateRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryRate
 ruleFunctionLibraryRate
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryRateAccess().getGroup()); }
 (rule__FunctionLibraryRate__Group__0)
 { after(grammarAccess.getFunctionLibraryRateAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionLibraryGuard
 entryRuleFunctionLibraryGuard
 :
 { before(grammarAccess.getFunctionLibraryGuardRule()); }
 	 ruleFunctionLibraryGuard
 { after(grammarAccess.getFunctionLibraryGuardRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryGuard
 ruleFunctionLibraryGuard
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryGuardAccess().getGroup()); }
 (rule__FunctionLibraryGuard__Group__0)
 { after(grammarAccess.getFunctionLibraryGuardAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionLibraryOperation
 entryRuleFunctionLibraryOperation
 :
 { before(grammarAccess.getFunctionLibraryOperationRule()); }
 	 ruleFunctionLibraryOperation
 { after(grammarAccess.getFunctionLibraryOperationRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryOperation
 ruleFunctionLibraryOperation
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryOperationAccess().getGroup()); }
 (rule__FunctionLibraryOperation__Group__0)
 { after(grammarAccess.getFunctionLibraryOperationAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleFunctionLibraryParameter
 entryRuleFunctionLibraryParameter
 :
 { before(grammarAccess.getFunctionLibraryParameterRule()); }
 	 ruleFunctionLibraryParameter
 { after(grammarAccess.getFunctionLibraryParameterRule()); }
 	 EOF
 ;

 // Rule FunctionLibraryParameter
 ruleFunctionLibraryParameter
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getFunctionLibraryParameterAccess().getGroup()); }
 (rule__FunctionLibraryParameter__Group__0)
 { after(grammarAccess.getFunctionLibraryParameterAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleTYPE_CROSS_REFERENCE
 entryRuleTYPE_CROSS_REFERENCE
 :
 { before(grammarAccess.getTYPE_CROSS_REFERENCERule()); }
 	 ruleTYPE_CROSS_REFERENCE
 { after(grammarAccess.getTYPE_CROSS_REFERENCERule()); }
 	 EOF
 ;

 // Rule TYPE_CROSS_REFERENCE
 ruleTYPE_CROSS_REFERENCE
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getTYPE_CROSS_REFERENCEAccess().getIDTerminalRuleCall()); }
 	RULE_ID
 { after(grammarAccess.getTYPE_CROSS_REFERENCEAccess().getIDTerminalRuleCall()); }
 )

 ;
 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()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleJvmArgumentTypeReference
 entryRuleJvmArgumentTypeReference
 :
 { before(grammarAccess.getJvmArgumentTypeReferenceRule()); }
 	 ruleJvmArgumentTypeReference
 { after(grammarAccess.getJvmArgumentTypeReferenceRule()); }
 	 EOF
 ;

 // Rule JvmArgumentTypeReference
 ruleJvmArgumentTypeReference
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); }
 (rule__JvmArgumentTypeReference__Alternatives)
 { after(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleJvmWildcardTypeReference
 entryRuleJvmWildcardTypeReference
 :
 { before(grammarAccess.getJvmWildcardTypeReferenceRule()); }
 	 ruleJvmWildcardTypeReference
 { after(grammarAccess.getJvmWildcardTypeReferenceRule()); }
 	 EOF
 ;

 // Rule JvmWildcardTypeReference
 ruleJvmWildcardTypeReference
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); }
 (rule__JvmWildcardTypeReference__Group__0)
 { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleJvmUpperBound
 entryRuleJvmUpperBound
 :
 { before(grammarAccess.getJvmUpperBoundRule()); }
 	 ruleJvmUpperBound
 { after(grammarAccess.getJvmUpperBoundRule()); }
 	 EOF
 ;

 // Rule JvmUpperBound
 ruleJvmUpperBound
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getJvmUpperBoundAccess().getGroup()); }
 (rule__JvmUpperBound__Group__0)
 { after(grammarAccess.getJvmUpperBoundAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleJvmUpperBoundAnded
 entryRuleJvmUpperBoundAnded
 :
 { before(grammarAccess.getJvmUpperBoundAndedRule()); }
 	 ruleJvmUpperBoundAnded
 { after(grammarAccess.getJvmUpperBoundAndedRule()); }
 	 EOF
 ;

 // Rule JvmUpperBoundAnded
 ruleJvmUpperBoundAnded
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); }
 (rule__JvmUpperBoundAnded__Group__0)
 { after(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleJvmLowerBound
 entryRuleJvmLowerBound
 :
 { before(grammarAccess.getJvmLowerBoundRule()); }
 	 ruleJvmLowerBound
 { after(grammarAccess.getJvmLowerBoundRule()); }
 	 EOF
 ;

 // Rule JvmLowerBound
 ruleJvmLowerBound
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getJvmLowerBoundAccess().getGroup()); }
 (rule__JvmLowerBound__Group__0)
 { after(grammarAccess.getJvmLowerBoundAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleJvmLowerBoundAnded
 entryRuleJvmLowerBoundAnded
 :
 { before(grammarAccess.getJvmLowerBoundAndedRule()); }
 	 ruleJvmLowerBoundAnded
 { after(grammarAccess.getJvmLowerBoundAndedRule()); }
 	 EOF
 ;

 // Rule JvmLowerBoundAnded
 ruleJvmLowerBoundAnded
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); }
 (rule__JvmLowerBoundAnded__Group__0)
 { after(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleQualifiedNameWithWildcard
 entryRuleQualifiedNameWithWildcard
 :
 { before(grammarAccess.getQualifiedNameWithWildcardRule()); }
 	 ruleQualifiedNameWithWildcard
 { after(grammarAccess.getQualifiedNameWithWildcardRule()); }
 	 EOF
 ;

 // Rule QualifiedNameWithWildcard
 ruleQualifiedNameWithWildcard
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 { before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); }
 (rule__QualifiedNameWithWildcard__Group__0)
 { after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); }
 )

 ;
 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().getIDTerminalRuleCall()); }
 	RULE_ID
 { after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 // Entry rule entryRuleXImportSection
 entryRuleXImportSection
 :
 { before(grammarAccess.getXImportSectionRule()); }
 	 ruleXImportSection
 { after(grammarAccess.getXImportSectionRule()); }
 	 EOF
 ;

 // Rule XImportSection
 ruleXImportSection
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 (
 { before(grammarAccess.getXImportSectionAccess().getImportDeclarationsAssignment()); }
 (rule__XImportSection__ImportDeclarationsAssignment)
 { after(grammarAccess.getXImportSectionAccess().getImportDeclarationsAssignment()); }
 )
 (
 { before(grammarAccess.getXImportSectionAccess().getImportDeclarationsAssignment()); }
 (rule__XImportSection__ImportDeclarationsAssignment)*
 { after(grammarAccess.getXImportSectionAccess().getImportDeclarationsAssignment()); }
 )
 )

 ;
 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 entryRuleQualifiedNameInStaticImport
 entryRuleQualifiedNameInStaticImport
 :
 { before(grammarAccess.getQualifiedNameInStaticImportRule()); }
 	 ruleQualifiedNameInStaticImport
 { after(grammarAccess.getQualifiedNameInStaticImportRule()); }
 	 EOF
 ;

 // Rule QualifiedNameInStaticImport
 ruleQualifiedNameInStaticImport
     @init {
 		int stackSize = keepStackSize();
     }
 	:
 (
 (
 { before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
 (rule__QualifiedNameInStaticImport__Group__0)
 { after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
 )
 (
 { before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
 (rule__QualifiedNameInStaticImport__Group__0)*
 { after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
 )
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }


 rule__FunctionLibraryPackage__Alternatives_5
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getFunctionLibraryPackageAccess().getGroupsAssignment_5_0()); }
 (rule__FunctionLibraryPackage__GroupsAssignment_5_0)
 { after(grammarAccess.getFunctionLibraryPackageAccess().getGroupsAssignment_5_0()); }
 )

     |(
 { before(grammarAccess.getFunctionLibraryPackageAccess().getRatingsAssignment_5_1()); }
 (rule__FunctionLibraryPackage__RatingsAssignment_5_1)
 { after(grammarAccess.getFunctionLibraryPackageAccess().getRatingsAssignment_5_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__FunctionLibraryPackage__GroupsAlternatives_5_0_0
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getFunctionLibraryPackageAccess().getGroupsFunctionLibraryGroupParserRuleCall_5_0_0_0()); }
 	ruleFunctionLibraryGroup
 { after(grammarAccess.getFunctionLibraryPackageAccess().getGroupsFunctionLibraryGroupParserRuleCall_5_0_0_0()); }
 )

     |(
 { before(grammarAccess.getFunctionLibraryPackageAccess().getGroupsFunctionLibraryBlipGroupParserRuleCall_5_0_0_1()); }
 	ruleFunctionLibraryBlipGroup
 { after(grammarAccess.getFunctionLibraryPackageAccess().getGroupsFunctionLibraryBlipGroupParserRuleCall_5_0_0_1()); }
 )

     |(
 { before(grammarAccess.getFunctionLibraryPackageAccess().getGroupsFunctionLibraryConverterGroupParserRuleCall_5_0_0_2()); }
 	ruleFunctionLibraryConverterGroup
 { after(grammarAccess.getFunctionLibraryPackageAccess().getGroupsFunctionLibraryConverterGroupParserRuleCall_5_0_0_2()); }
 )

     |(
 { before(grammarAccess.getFunctionLibraryPackageAccess().getGroupsFunctionLibraryStatemachineGroupParserRuleCall_5_0_0_3()); }
 	ruleFunctionLibraryStatemachineGroup
 { after(grammarAccess.getFunctionLibraryPackageAccess().getGroupsFunctionLibraryStatemachineGroupParserRuleCall_5_0_0_3()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__FunctionLibraryGroup__Alternatives_3
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getFunctionLibraryGroupAccess().getFunctionsAssignment_3_0()); }
 (rule__FunctionLibraryGroup__FunctionsAssignment_3_0)
 { after(grammarAccess.getFunctionLibraryGroupAccess().getFunctionsAssignment_3_0()); }
 )

     |(
 { before(grammarAccess.getFunctionLibraryGroupAccess().getTestsAssignment_3_1()); }
 (rule__FunctionLibraryGroup__TestsAssignment_3_1)
 { after(grammarAccess.getFunctionLibraryGroupAccess().getTestsAssignment_3_1()); }
 )

     |(
 { before(grammarAccess.getFunctionLibraryGroupAccess().getRatesAssignment_3_2()); }
 (rule__FunctionLibraryGroup__RatesAssignment_3_2)
 { after(grammarAccess.getFunctionLibraryGroupAccess().getRatesAssignment_3_2()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__FunctionLibraryBlipGroup__Alternatives_3
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getFunctionLibraryBlipGroupAccess().getFunctionsAssignment_3_0()); }
 (rule__FunctionLibraryBlipGroup__FunctionsAssignment_3_0)
 { after(grammarAccess.getFunctionLibraryBlipGroupAccess().getFunctionsAssignment_3_0()); }
 )

     |(
 { before(grammarAccess.getFunctionLibraryBlipGroupAccess().getTestsAssignment_3_1()); }
 (rule__FunctionLibraryBlipGroup__TestsAssignment_3_1)
 { after(grammarAccess.getFunctionLibraryBlipGroupAccess().getTestsAssignment_3_1()); }
 )

     |(
 { before(grammarAccess.getFunctionLibraryBlipGroupAccess().getRatesAssignment_3_2()); }
 (rule__FunctionLibraryBlipGroup__RatesAssignment_3_2)
 { after(grammarAccess.getFunctionLibraryBlipGroupAccess().getRatesAssignment_3_2()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__FunctionLibraryStatemachineGroup__Alternatives_3
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getFunctionLibraryStatemachineGroupAccess().getOperationsAssignment_3_0()); }
 (rule__FunctionLibraryStatemachineGroup__OperationsAssignment_3_0)
 { after(grammarAccess.getFunctionLibraryStatemachineGroupAccess().getOperationsAssignment_3_0()); }
 )

     |(
 { before(grammarAccess.getFunctionLibraryStatemachineGroupAccess().getGuardsAssignment_3_1()); }
 (rule__FunctionLibraryStatemachineGroup__GuardsAssignment_3_1)
 { after(grammarAccess.getFunctionLibraryStatemachineGroupAccess().getGuardsAssignment_3_1()); }
 )

     |(
 { before(grammarAccess.getFunctionLibraryStatemachineGroupAccess().getFunctionsAssignment_3_2()); }
 (rule__FunctionLibraryStatemachineGroup__FunctionsAssignment_3_2)
 { after(grammarAccess.getFunctionLibraryStatemachineGroupAccess().getFunctionsAssignment_3_2()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__XAnnotation__Alternatives_3_1
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getXAnnotationAccess().getGroup_3_1_0()); }
 (rule__XAnnotation__Group_3_1_0__0)
 { after(grammarAccess.getXAnnotationAccess().getGroup_3_1_0()); }
 )

     |(
 { before(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1()); }
 (rule__XAnnotation__ValueAssignment_3_1_1)
 { after(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__XAnnotationElementValueOrCommaList__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0()); }
 (rule__XAnnotationElementValueOrCommaList__Group_0__0)
 { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0()); }
 )

     |(
 { before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1()); }
 (rule__XAnnotationElementValueOrCommaList__Group_1__0)
 { after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__XAnnotationElementValue__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0()); }
 (rule__XAnnotationElementValue__Group_0__0)
 { after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0()); }
 )

     |(
 { before(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1()); }
 	ruleXAnnotationOrExpression
 { after(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__XAnnotationOrExpression__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0()); }
 	ruleXAnnotation
 { after(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0()); }
 )

     |(
 { before(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1()); }
 	ruleXExpression
 { after(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__XAssignment__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getXAssignmentAccess().getGroup_0()); }
 (rule__XAssignment__Group_0__0)
 { after(grammarAccess.getXAssignmentAccess().getGroup_0()); }
 )

     |(
 { before(grammarAccess.getXAssignmentAccess().getGroup_1()); }
 (rule__XAssignment__Group_1__0)
 { after(grammarAccess.getXAssignmentAccess().getGroup_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__OpMultiAssign__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); }

 	'+='

 { after(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); }
 )

     |(
 { before(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); }

 	'-='

 { after(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); }
 )

     |(
 { before(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); }

 	'*='

 { after(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); }
 )

     |(
 { before(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); }

 	'/='

 { after(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); }
 )

     |(
 { before(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); }

 	'%='

 { after(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); }
 )

     |(
 { before(grammarAccess.getOpMultiAssignAccess().getGroup_5()); }
 (rule__OpMultiAssign__Group_5__0)
 { after(grammarAccess.getOpMultiAssignAccess().getGroup_5()); }
 )

     |(
 { before(grammarAccess.getOpMultiAssignAccess().getGroup_6()); }
 (rule__OpMultiAssign__Group_6__0)
 { after(grammarAccess.getOpMultiAssignAccess().getGroup_6()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__OpEquality__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); }

 	'=='

 { after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); }
 )

     |(
 { before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); }

 	'!='

 { after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); }
 )

     |(
 { before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); }

 	'==='

 { after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); }
 )

     |(
 { before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); }

 	'!=='

 { after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__XRelationalExpression__Alternatives_1
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); }
 (rule__XRelationalExpression__Group_1_0__0)
 { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); }
 )

     |(
 { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); }
 (rule__XRelationalExpression__Group_1_1__0)
 { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__OpCompare__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); }

 	'>='

 { after(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); }
 )

     |(
 { before(grammarAccess.getOpCompareAccess().getGroup_1()); }
 (rule__OpCompare__Group_1__0)
 { after(grammarAccess.getOpCompareAccess().getGroup_1()); }
 )

     |(
 { before(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); }

 	'>'

 { after(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); }
 )

     |(
 { before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); }

 	'<'

 { after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__OpOther__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); }

 	'->'

 { after(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
 )

     |(
 { before(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); }

 	'..<'

 { after(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); }
 )

     |(
 { before(grammarAccess.getOpOtherAccess().getGroup_2()); }
 (rule__OpOther__Group_2__0)
 { after(grammarAccess.getOpOtherAccess().getGroup_2()); }
 )

     |(
 { before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); }

 	'..'

 { after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); }
 )

     |(
 { before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); }

 	'=>'

 { after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); }
 )

     |(
 { before(grammarAccess.getOpOtherAccess().getGroup_5()); }
 (rule__OpOther__Group_5__0)
 { after(grammarAccess.getOpOtherAccess().getGroup_5()); }
 )

     |(
 { before(grammarAccess.getOpOtherAccess().getGroup_6()); }
 (rule__OpOther__Group_6__0)
 { after(grammarAccess.getOpOtherAccess().getGroup_6()); }
 )

     |(
 { before(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); }

 	'<>'

 { after(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); }
 )

     |(
 { before(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); }

 	'?:'

 { after(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__OpOther__Alternatives_5_1
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); }
 (rule__OpOther__Group_5_1_0__0)
 { after(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); }
 )

     |(
 { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); }

 	'>'

 { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__OpOther__Alternatives_6_1
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); }
 (rule__OpOther__Group_6_1_0__0)
 { after(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); }
 )

     |(
 { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); }

 	'<'

 { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); }
 )

     |(
 { before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); }

 	'=>'

 { after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__OpAdd__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); }

 	'+'

 { after(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); }
 )

     |(
 { before(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); }

 	'-'

 { after(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__OpMulti__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); }

 	'*'

 { after(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); }
 )

     |(
 { before(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); }

 	'**'

 { after(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); }
 )

     |(
 { before(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); }

 	'/'

 { after(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); }
 )

     |(
 { before(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); }

 	'%'

 { after(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__XUnaryOperation__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getXUnaryOperationAccess().getGroup_0()); }
 (rule__XUnaryOperation__Group_0__0)
 { after(grammarAccess.getXUnaryOperationAccess().getGroup_0()); }
 )

     |(
 { before(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); }
 	ruleXCastedExpression
 { after(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__OpUnary__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); }

 	'!'

 { after(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); }
 )

     |(
 { before(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); }

 	'-'

 { after(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); }
 )

     |(
 { before(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); }

 	'+'

 { after(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__OpPostfix__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); }

 	'++'

 { after(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); }
 )

     |(
 { before(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); }

 	'--'

 { after(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__XMemberFeatureCall__Alternatives_1
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); }
 (rule__XMemberFeatureCall__Group_1_0__0)
 { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); }
 )

     |(
 { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); }
 (rule__XMemberFeatureCall__Group_1_1__0)
 { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__XMemberFeatureCall__Alternatives_1_0_0_0_1
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); }

 	'.'

 { after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); }
 )

     |(
 { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); }
 (rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1)
 { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__XMemberFeatureCall__Alternatives_1_1_0_0_1
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); }

 	'.'

 { after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); }
 )

     |(
 { before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); }
 (rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1)
 { after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); }
 )

     |(
 { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); }
 (rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2)
 { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__XMemberFeatureCall__Alternatives_1_1_3_1
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); }
 (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0)
 { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); }
 )

     |(
 { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); }
 (rule__XMemberFeatureCall__Group_1_1_3_1_1__0)
 { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); }
 )

 ;
 finally {
 	restoreStackSize(stackSize);
 }

 rule__XPrimaryExpression__Alternatives
     @init {
 		int stackSize = keepStackSize();
     }
 :
 (
 { before(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); }
 	ruleXConstructorCall
 { after(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); }
 )

     |(
 { before(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); }
 	ruleXBlockExpression
 { after(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); }
 )

     |(
 { before(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); }
 	ruleXSwitchExpression
 { after(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); }
 )

     |(
 { before(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); }
 (	ruleXSynchronizedExpression)
 { after(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); }
 )

     |(
 { before(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); }
 	ruleXFeatureCall
 { after(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); }
 )

     |(
 { before(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); }
 	ruleXLiteral
 { after(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); }
 )

     |(
 { before(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); }
 	ruleXIfExpression
 { after(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); }
 )

     |(
 { before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); }
 (	ruleXForLoopExpression)
 { after(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); }