Version 0.9 of the alf editor, compatible with Papyrus 0.8

24 files changed, 79494 insertions, 0 deletions

diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.classpath b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.classpath
new file mode 100644
index 00000000000..ed2585fb3f4
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<classpath>

+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>

+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>

+	<classpathentry kind="src" path="src"/>

+	<classpathentry kind="src" path="src-gen"/>

+	<classpathentry kind="output" path="bin"/>

+</classpath>

diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.project b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.project
new file mode 100644
index 00000000000..4cf1acb6870
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<projectDescription>

+	<name>org.eclipse.papyrus.alf.ui</name>

+	<comment></comment>

+	<projects>

+	</projects>

+	<buildSpec>

+		<buildCommand>

+			<name>org.eclipse.jdt.core.javabuilder</name>

+			<arguments>

+			</arguments>

+		</buildCommand>

+		<buildCommand>

+			<name>org.eclipse.pde.ManifestBuilder</name>

+			<arguments>

+			</arguments>

+		</buildCommand>

+		<buildCommand>

+			<name>org.eclipse.pde.SchemaBuilder</name>

+			<arguments>

+			</arguments>

+		</buildCommand>

+	</buildSpec>

+	<natures>

+		<nature>org.eclipse.jdt.core.javanature</nature>

+		<nature>org.eclipse.pde.PluginNature</nature>

+	</natures>

+</projectDescription>

diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/net.sf.jautodoc.prefs b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/net.sf.jautodoc.prefs
new file mode 100644
index 00000000000..f90fca076bd
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/net.sf.jautodoc.prefs
@@ -0,0 +1,7 @@
+#Tue Apr 17 18:17:17 CEST 2012

+add_header=true

+eclipse.preferences.version=1

+header_text=/*****************************************************************************\r\n * Copyright (c) 2011 CEA LIST.\r\n *\r\n *    \r\n * All rights reserved. This program and the accompanying materials\r\n * are made available under the terms of the Eclipse Public License v1.0\r\n * which accompanies this distribution, and is available at\r\n * http\://www.eclipse.org/legal/epl-v10.html\r\n *\r\n * Contributors\:\r\n *  CEA LIST - Initial API and implementation\r\n *\r\n *****************************************************************************/

+project_specific_settings=true

+replace_header=true

+replacements=<?xml version\="1.0" standalone\="yes"?>\n\n<replacements>\n<replacement key\="get" scope\="1" mode\="0">Gets the</replacement>\n<replacement key\="set" scope\="1" mode\="0">Sets the</replacement>\n<replacement key\="add" scope\="1" mode\="0">Adds the</replacement>\n<replacement key\="edit" scope\="1" mode\="0">Edits the</replacement>\n<replacement key\="remove" scope\="1" mode\="0">Removes the</replacement>\n<replacement key\="init" scope\="1" mode\="0">Inits the</replacement>\n<replacement key\="parse" scope\="1" mode\="0">Parses the</replacement>\n<replacement key\="create" scope\="1" mode\="0">Creates the</replacement>\n<replacement key\="build" scope\="1" mode\="0">Builds the</replacement>\n<replacement key\="is" scope\="1" mode\="0">Checks if is</replacement>\n<replacement key\="print" scope\="1" mode\="0">Prints the</replacement>\n<replacement key\="has" scope\="1" mode\="0">Checks for</replacement>\n</replacements>\n\n

diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/org.eclipse.jdt.core.prefs b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 00000000000..47447961c5c
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,12 @@
+#Tue Apr 26 18:50:13 CEST 2011

+eclipse.preferences.version=1

+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled

+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5

+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve

+org.eclipse.jdt.core.compiler.compliance=1.5

+org.eclipse.jdt.core.compiler.debug.lineNumber=generate

+org.eclipse.jdt.core.compiler.debug.localVariable=generate

+org.eclipse.jdt.core.compiler.debug.sourceFile=generate

+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error

+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error

+org.eclipse.jdt.core.compiler.source=1.5

diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/META-INF/MANIFEST.MF b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/META-INF/MANIFEST.MF
new file mode 100644
index 00000000000..76872f852c1
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/META-INF/MANIFEST.MF
@@ -0,0 +1,22 @@
+Manifest-Version: 1.0

+Bundle-ManifestVersion: 2

+Bundle-Name: org.eclipse.papyrus.alf.ui

+Bundle-Vendor: Eclipse Modeling Project

+Bundle-Version: 0.9.0.qualifier

+Bundle-SymbolicName: org.eclipse.papyrus.alf.ui; singleton:=true

+Bundle-ActivationPolicy: lazy

+Require-Bundle: org.eclipse.papyrus.alf;visibility:=reexport,

+ org.eclipse.xtext.ui,

+ org.eclipse.ui.editors;bundle-version="3.5.0",

+ org.eclipse.ui.ide;bundle-version="3.5.0",

+ org.eclipse.xtext.ui.shared,

+ org.eclipse.ui,

+ org.eclipse.xtext.builder,

+ org.antlr.runtime,

+ org.eclipse.uml2.uml;bundle-version="3.2.0",

+ org.eclipse.xtext.gmf.glue;bundle-version="0.8.2"

+Import-Package: org.apache.log4j

+Bundle-RequiredExecutionEnvironment: J2SE-1.5

+Bundle-Activator: org.eclipse.papyrus.alf.ui.internal.AlfActivator

+Export-Package: org.eclipse.papyrus.alf.ui.contentassist,

+ org.eclipse.papyrus.alf.ui.contentassist.antlr

diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.properties b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.properties
new file mode 100644
index 00000000000..e10dcceb6a3
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.properties
@@ -0,0 +1,5 @@
+source.. = src/,\
+          src-gen/
+bin.includes = META-INF/,\
+               .,\
+               plugin.xml
\ No newline at end of file
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.xml b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.xml
new file mode 100644
index 00000000000..753cb8050ca
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/build.xml
@@ -0,0 +1,89 @@
+<project name="org.eclipse.papyrus.alf.ui" basedir=".">

+	

+		<!-- Define the build directories-->

+		<property name="src.dir" value="${basedir}\src"/>

+		<property name="src.gen.dir" value="${basedir}\src-gen"/>

+		<property name="build.dir" value="${basedir}\bin"/>

+		<property name="build.infos.dir" value="${basedir}\buildinfos"/>

+	

+		<!-- Define the location were javac can find required plugins -->

+		<property environment="env"/>

+		<path id="eclipse.classpath">

+			<fileset dir="${env.ECLIPSE_HOME}\plugins">

+				<include name="*.jar"/>

+			</fileset>

+		</path>

+	

+		<!-- Define the location were lib used by pmd are stored -->

+		<path id="pmd.classpath">

+			<fileset dir="${env.PMD_HOME}\lib">

+				<include name="*.jar"/>

+			</fileset>

+		</path>

+	

+		<!-- Define the location of the jar file containing the alf implementation-->

+		<path id="org.eclipse.papyrus.alf">

+			<fileset dir="..\..\org.eclipse.papyrus.alf\workspace\plugin">

+				<include name="org.eclipse.papyrus.alf.jar"/>

+			</fileset>

+		</path>

+	

+		<!-- Define entry point when you find an element named findbugs -->

+		<taskdef name="findbugs" classpath="${env.FINDBUGS_HOME}\lib\findbugs-ant.jar"  classname="edu.umd.cs.findbugs.anttask.FindBugsTask"/>

+		

+		<!-- Define entry point when you find an element named PMD -->

+		<taskdef name="pmd" classpathref="pmd.classpath"  classname="net.sourceforge.pmd.ant.PMDTask"/>

+	

+		<!-- Set up directories for the build and info that have to be retrieved in hudson-->

+		<target name="init">

+			<tstamp/>

+			<delete dir="${build.dir}"/>

+			<mkdir dir="${build.dir}"/>

+			<delete dir="${build.infos.dir}"/>

+			<mkdir dir="${build.infos.dir}"/>

+			<mkdir dir="${build.infos.dir}\bugsreport"/>

+			<mkdir dir="${build.infos.dir}\checkstyle"/>

+		</target>

+	

+		<!-- Perfom a  checkstyle on the code with pmd tool. Compiling is not required -->

+		<target name="pmd" depends="init">

+			<pmd shortfilenames="true">

+				<ruleset>${env.PMD_HOME}\lib\rulesets\java\basic.xml</ruleset>

+				<ruleset>${env.PMD_HOME}\lib\rulesets\java\unusedcode.xml</ruleset>

+				<ruleset>${env.PMD_HOME}\lib\rulesets\java\unnecessary.xml</ruleset>

+				<ruleset>${env.PMD_HOME}\lib\rulesets\java\codesize.xml</ruleset>

+				<ruleset>${env.PMD_HOME}\lib\rulesets\java\strictexception.xml</ruleset>

+				<ruleset>${env.PMD_HOME}\lib\rulesets\java\braces.xml</ruleset>

+				<formatter type="xml" toFile="${build.infos.dir}\checkstyle\${ant.project.name}.pmd.xml"/>

+				<fileset dir="${src.dir}">

+					<include name="**/*.java"/>

+				</fileset>

+				<auxclasspath path="${src.gen.dir}"/>

+			</pmd>

+		</target>

+		

+		<!-- Compilation phase of the project -->

+		<target name="compile" depends="pmd">

+			<echo message="${toString:org.eclipse.papyrus.alf}"/>

+			<javac includeantruntime="false" srcdir="${src.dir}" destdir="${build.dir}">

+				<compilerarg value="-Xlint:all"/>

+				<classpath refid="org.eclipse.papyrus.alf"/>

+				<classpath refid="eclipse.classpath"/>

+			</javac>

+			<javac includeantruntime="false" srcdir="${src.gen.dir}" destdir="${build.dir}">

+				<compilerarg value="-Xlint:all"/>

+				<classpath refid="org.eclipse.papyrus.alf"/>

+				<classpath refid="eclipse.classpath"/>

+			</javac>

+		</target>

+	

+		<!-- Try to detect bugs within code after compiling -->

+		<target name="findbugs" depends="compile">

+			<findbugs home="${env.FINDBUGS_HOME}" output="xml" outputfile="${build.infos.dir}\bugsreport\${ant.project.name}.sa.xml">

+				<class location="${build.dir}"/>

+				<auxclasspath refid="eclipse.classpath"/>

+				<auxclasspath path="${src.gen.dir}"/>

+				<sourcePath path="${src.dir}"/>

+			</findbugs>

+		</target>

+</project>
\ No newline at end of file
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml
new file mode 100644
index 00000000000..b0d8a26d0bd
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml
@@ -0,0 +1,184 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<plugin>
+
+    <extension
+            point="org.eclipse.ui.editors">
+        <editor
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.XtextEditor"
+            contributorClass="org.eclipse.ui.editors.text.TextEditorActionContributor"
+            default="true"
+            extensions="alf"
+            id="org.eclipse.papyrus.alf.Alf"
+            name="Alf Editor">
+        </editor>
+    </extension>
+    <extension
+        point="org.eclipse.ui.handlers">
+        <handler
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclarationHandler"
+            commandId="org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclaration">
+            <activeWhen>
+                <reference
+                    definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+                </reference>
+            </activeWhen>
+        </handler>
+        <handler
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.handler.ValidateActionHandler"
+            commandId="org.eclipse.papyrus.alf.Alf.validate">
+         <activeWhen>
+            <reference
+                    definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+            </reference>
+         </activeWhen>
+      </handler>
+    </extension>
+    <extension point="org.eclipse.core.expressions.definitions">
+        <definition id="org.eclipse.papyrus.alf.Alf.Editor.opened">
+            <and>
+                <reference definitionId="isActiveEditorAnInstanceOfXtextEditor"/>
+                <with variable="activeEditor">
+                    <test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName" 
+                        value="org.eclipse.papyrus.alf.Alf" 
+                        forcePluginActivation="true"/>
+                </with>        
+            </and>
+        </definition>
+    </extension>
+    <extension
+            point="org.eclipse.ui.preferencePages">
+        <page
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage"
+            id="org.eclipse.papyrus.alf.Alf"
+            name="Alf">
+            <keywordReference id="org.eclipse.papyrus.alf.ui.keyword_Alf"/>
+        </page>
+        <page
+            category="org.eclipse.papyrus.alf.Alf"
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.syntaxcoloring.SyntaxColoringPreferencePage"
+            id="org.eclipse.papyrus.alf.Alf.coloring"
+            name="Syntax Coloring">
+            <keywordReference id="org.eclipse.papyrus.alf.ui.keyword_Alf"/>
+        </page>
+        <page
+            category="org.eclipse.papyrus.alf.Alf"
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage"
+            id="org.eclipse.papyrus.alf.Alf.templates"
+            name="Templates">
+            <keywordReference id="org.eclipse.papyrus.alf.ui.keyword_Alf"/>
+        </page>
+    </extension>
+    <extension
+        point="org.eclipse.ui.keywords">
+        <keyword
+            id="org.eclipse.papyrus.alf.ui.keyword_Alf"
+            label="Alf"/>
+    </extension>
+    <extension
+         point="org.eclipse.ui.commands">
+      <command
+            description="Trigger expensive validation"
+            id="org.eclipse.papyrus.alf.Alf.validate"
+            name="Validate">
+      </command>
+    </extension>
+    <extension point="org.eclipse.ui.menus">
+        <menuContribution
+            locationURI="popup:#TextEditorContext?after=group.edit">
+             <command
+                 commandId="org.eclipse.papyrus.alf.Alf.validate"
+                 style="push"
+                 tooltip="Trigger expensive validation">
+            <visibleWhen checkEnabled="false">
+                <reference
+                    definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+                </reference>
+            </visibleWhen>
+         </command>  
+         </menuContribution>
+    </extension>
+    <extension point="org.eclipse.ui.menus">
+		<menuContribution locationURI="popup:#TextEditorContext?endof=group.find">
+			<command commandId="org.eclipse.xtext.ui.editor.FindReferences">
+				<visibleWhen checkEnabled="false">
+                	<reference definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+                	</reference>
+            	</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.ui.handlers">
+	    <handler
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler"
+            commandId="org.eclipse.xtext.ui.editor.FindReferences">
+            <activeWhen>
+                <reference
+                    definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+                </reference>
+            </activeWhen>
+        </handler>
+    </extension>   
+
+<!-- adding resource factories -->
+
+	<extension
+		point="org.eclipse.emf.ecore.extension_parser">
+		<parser
+			class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.resource.IResourceFactory"
+			type="alf">
+		</parser>
+	</extension>
+	<extension point="org.eclipse.xtext.extension_resourceServiceProvider">
+        <resourceServiceProvider
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.resource.IResourceUIServiceProvider"
+            uriExtension="alf">
+        </resourceServiceProvider>
+    </extension>
+
+
+
+
+	<!-- Quick Outline -->
+	<extension
+		point="org.eclipse.ui.handlers">
+		<handler 
+			class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.outline.quickoutline.ShowQuickOutlineActionHandler"
+			commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension
+		point="org.eclipse.ui.commands">
+		<command
+			description="Open the quick outline."
+			id="org.eclipse.xtext.ui.editor.outline.QuickOutline"
+			name="Quick Outline">
+		</command>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.open">
+			<command commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline"
+				style="push"
+				tooltip="Open Quick Outline">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened"/>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+   <!-- quickfix marker resolution generator -->
+   <extension
+         point="org.eclipse.ui.ide.markerResolution">
+      <markerResolutionGenerator
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator">
+      </markerResolutionGenerator>
+   </extension>
+
+</plugin>
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml_gen b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml_gen
new file mode 100644
index 00000000000..938feb4acd5
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/plugin.xml_gen
@@ -0,0 +1,183 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+
+<plugin>
+
+    <extension
+            point="org.eclipse.ui.editors">
+        <editor
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.XtextEditor"
+            contributorClass="org.eclipse.ui.editors.text.TextEditorActionContributor"
+            default="true"
+            extensions="alf"
+            id="org.eclipse.papyrus.alf.Alf"
+            name="Alf Editor">
+        </editor>
+    </extension>
+    <extension
+        point="org.eclipse.ui.handlers">
+        <handler
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclarationHandler"
+            commandId="org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclaration">
+            <activeWhen>
+                <reference
+                    definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+                </reference>
+            </activeWhen>
+        </handler>
+        <handler
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.handler.ValidateActionHandler"
+            commandId="org.eclipse.papyrus.alf.Alf.validate">
+         <activeWhen>
+            <reference
+                    definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+            </reference>
+         </activeWhen>
+      </handler>
+    </extension>
+    <extension point="org.eclipse.core.expressions.definitions">
+        <definition id="org.eclipse.papyrus.alf.Alf.Editor.opened">
+            <and>
+                <reference definitionId="isActiveEditorAnInstanceOfXtextEditor"/>
+                <with variable="activeEditor">
+                    <test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName" 
+                        value="org.eclipse.papyrus.alf.Alf" 
+                        forcePluginActivation="true"/>
+                </with>        
+            </and>
+        </definition>
+    </extension>
+    <extension
+            point="org.eclipse.ui.preferencePages">
+        <page
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage"
+            id="org.eclipse.papyrus.alf.Alf"
+            name="Alf">
+            <keywordReference id="org.eclipse.papyrus.alf.ui.keyword_Alf"/>
+        </page>
+        <page
+            category="org.eclipse.papyrus.alf.Alf"
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.syntaxcoloring.SyntaxColoringPreferencePage"
+            id="org.eclipse.papyrus.alf.Alf.coloring"
+            name="Syntax Coloring">
+            <keywordReference id="org.eclipse.papyrus.alf.ui.keyword_Alf"/>
+        </page>
+        <page
+            category="org.eclipse.papyrus.alf.Alf"
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage"
+            id="org.eclipse.papyrus.alf.Alf.templates"
+            name="Templates">
+            <keywordReference id="org.eclipse.papyrus.alf.ui.keyword_Alf"/>
+        </page>
+    </extension>
+    <extension
+        point="org.eclipse.ui.keywords">
+        <keyword
+            id="org.eclipse.papyrus.alf.ui.keyword_Alf"
+            label="Alf"/>
+    </extension>
+    <extension
+         point="org.eclipse.ui.commands">
+      <command
+            description="Trigger expensive validation"
+            id="org.eclipse.papyrus.alf.Alf.validate"
+            name="Validate">
+      </command>
+    </extension>
+    <extension point="org.eclipse.ui.menus">
+        <menuContribution
+            locationURI="popup:#TextEditorContext?after=group.edit">
+             <command
+                 commandId="org.eclipse.papyrus.alf.Alf.validate"
+                 style="push"
+                 tooltip="Trigger expensive validation">
+            <visibleWhen checkEnabled="false">
+                <reference
+                    definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+                </reference>
+            </visibleWhen>
+         </command>  
+         </menuContribution>
+    </extension>
+    <extension point="org.eclipse.ui.menus">
+		<menuContribution locationURI="popup:#TextEditorContext?endof=group.find">
+			<command commandId="org.eclipse.xtext.ui.editor.FindReferences">
+				<visibleWhen checkEnabled="false">
+                	<reference definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+                	</reference>
+            	</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.ui.handlers">
+	    <handler
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler"
+            commandId="org.eclipse.xtext.ui.editor.FindReferences">
+            <activeWhen>
+                <reference
+                    definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+                </reference>
+            </activeWhen>
+        </handler>
+    </extension>   
+
+<!-- adding resource factories -->
+
+	<extension
+		point="org.eclipse.emf.ecore.extension_parser">
+		<parser
+			class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.resource.IResourceFactory"
+			type="alf">
+		</parser>
+	</extension>
+	<extension point="org.eclipse.xtext.extension_resourceServiceProvider">
+        <resourceServiceProvider
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.resource.IResourceUIServiceProvider"
+            uriExtension="alf">
+        </resourceServiceProvider>
+    </extension>
+
+
+
+	<!-- Quick Outline -->
+	<extension
+		point="org.eclipse.ui.handlers">
+		<handler 
+			class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.outline.quickoutline.ShowQuickOutlineActionHandler"
+			commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension
+		point="org.eclipse.ui.commands">
+		<command
+			description="Open the quick outline."
+			id="org.eclipse.xtext.ui.editor.outline.QuickOutline"
+			name="Quick Outline">
+		</command>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.open">
+			<command commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline"
+				style="push"
+				tooltip="Open Quick Outline">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.papyrus.alf.Alf.Editor.opened"/>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+   <!-- quickfix marker resolution generator -->
+   <extension
+         point="org.eclipse.ui.ide.markerResolution">
+      <markerResolutionGenerator
+            class="org.eclipse.papyrus.alf.ui.AlfExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator">
+      </markerResolutionGenerator>
+   </extension>
+
+</plugin>
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AbstractAlfUiModule.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AbstractAlfUiModule.java
new file mode 100644
index 00000000000..ee633226c1a
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AbstractAlfUiModule.java
@@ -0,0 +1,97 @@
+
+/*
+ * generated by Xtext
+ */
+package org.eclipse.papyrus.alf.ui;
+
+import org.eclipse.xtext.ui.DefaultUiModule;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+
+/**
+ * Manual modifications go to {org.eclipse.papyrus.alf.ui.AlfUiModule}
+ */
+@SuppressWarnings("all")
+public abstract class AbstractAlfUiModule extends DefaultUiModule {
+	
+	public AbstractAlfUiModule(AbstractUIPlugin plugin) {
+		super(plugin);
+	}
+	
+	
+	// contributed by org.eclipse.xtext.ui.generator.ImplicitUiFragment
+	public com.google.inject.Provider<org.eclipse.xtext.resource.containers.IAllContainersState> provideIAllContainersState() {
+		return org.eclipse.xtext.ui.shared.Access.getJavaProjectsState();
+	}
+
+	// contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+	public Class<? extends org.eclipse.xtext.ui.editor.contentassist.IProposalConflictHelper> bindIProposalConflictHelper() {
+		return org.eclipse.xtext.ui.editor.contentassist.antlr.AntlrProposalConflictHelper.class;
+	}
+
+	// contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+	public void configureHighlightingLexer(com.google.inject.Binder binder) {
+		binder.bind(org.eclipse.xtext.parser.antlr.Lexer.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.HIGHLIGHTING)).to(org.eclipse.papyrus.alf.parser.antlr.internal.InternalAlfLexer.class);
+	}
+
+	// contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment
+	public void configureHighlightingTokenDefProvider(com.google.inject.Binder binder) {
+		binder.bind(org.eclipse.xtext.parser.antlr.ITokenDefProvider.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.HIGHLIGHTING)).to(org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider.class);
+	}
+
+	// contributed by org.eclipse.xtext.generator.exporting.SimpleNamesFragment
+	public Class<? extends org.eclipse.xtext.ui.refactoring.IDependentElementsCalculator> bindIDependentElementsCalculator() {
+		return org.eclipse.xtext.ui.refactoring.IDependentElementsCalculator.Null.class;
+	}
+
+	// contributed by org.eclipse.xtext.ui.generator.labeling.LabelProviderFragment
+	public Class<? extends org.eclipse.jface.viewers.ILabelProvider> bindILabelProvider() {
+		return org.eclipse.papyrus.alf.ui.labeling.AlfLabelProvider.class;
+	}
+
+	// contributed by org.eclipse.xtext.ui.generator.labeling.LabelProviderFragment
+	public void configureResourceUIServiceLabelProvider(com.google.inject.Binder binder) {
+		binder.bind(org.eclipse.jface.viewers.ILabelProvider.class).annotatedWith(org.eclipse.xtext.ui.resource.ResourceServiceDescriptionLabelProvider.class).to(org.eclipse.papyrus.alf.ui.labeling.AlfDescriptionLabelProvider.class);
+	}
+
+	// contributed by org.eclipse.xtext.ui.generator.outline.OutlineTreeProviderFragment
+	public Class<? extends org.eclipse.xtext.ui.editor.outline.IOutlineTreeProvider> bindIOutlineTreeProvider() {
+		return org.eclipse.papyrus.alf.ui.outline.AlfOutlineTreeProvider.class;
+	}
+
+	// contributed by org.eclipse.xtext.ui.generator.outline.OutlineTreeProviderFragment
+	public Class<? extends org.eclipse.xtext.ui.editor.outline.impl.IOutlineTreeStructureProvider> bindIOutlineTreeStructureProvider() {
+		return org.eclipse.papyrus.alf.ui.outline.AlfOutlineTreeProvider.class;
+	}
+
+	// contributed by org.eclipse.xtext.ui.generator.quickfix.QuickfixProviderFragment
+	public Class<? extends org.eclipse.xtext.ui.editor.quickfix.IssueResolutionProvider> bindIssueResolutionProvider() {
+		return org.eclipse.papyrus.alf.ui.quickfix.AlfQuickfixProvider.class;
+	}
+
+	// contributed by org.eclipse.xtext.ui.generator.contentAssist.JavaBasedContentAssistFragment
+	public Class<? extends org.eclipse.xtext.ui.editor.contentassist.IContentProposalProvider> bindIContentProposalProvider() {
+		return org.eclipse.papyrus.alf.ui.contentassist.AlfProposalProvider.class;
+	}
+
+	// contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment
+	public Class<? extends org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext.Factory> bindContentAssistContext$Factory() {
+		return org.eclipse.xtext.ui.editor.contentassist.antlr.ParserBasedContentAssistContextFactory.class;
+	}
+
+	// contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment
+	public Class<? extends org.eclipse.xtext.ui.editor.contentassist.antlr.IContentAssistParser> bindIContentAssistParser() {
+		return org.eclipse.papyrus.alf.ui.contentassist.antlr.AlfParser.class;
+	}
+
+	// contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment
+	public void configureContentAssistLexerProvider(com.google.inject.Binder binder) {
+		binder.bind(org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfLexer.class).toProvider(org.eclipse.xtext.parser.antlr.LexerProvider.create(org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfLexer.class));
+	}
+
+	// contributed by org.eclipse.xtext.generator.parser.antlr.XtextAntlrUiGeneratorFragment
+	public void configureContentAssistLexer(com.google.inject.Binder binder) {
+		binder.bind(org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer.class).annotatedWith(com.google.inject.name.Names.named(org.eclipse.xtext.ui.LexerUIBindings.CONTENT_ASSIST)).to(org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfLexer.class);
+	}
+
+
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AlfExecutableExtensionFactory.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AlfExecutableExtensionFactory.java
new file mode 100644
index 00000000000..5cf50829ae8
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/AlfExecutableExtensionFactory.java
@@ -0,0 +1,27 @@
+/*
+ * generated by Xtext
+ */
+package org.eclipse.papyrus.alf.ui;
+
+import org.eclipse.xtext.ui.guice.AbstractGuiceAwareExecutableExtensionFactory;
+import org.osgi.framework.Bundle;
+
+import com.google.inject.Injector;
+
+/**
+ * This class was generated. Customizations should only happen in a newly
+ * introduced subclass. 
+ */
+public class AlfExecutableExtensionFactory extends AbstractGuiceAwareExecutableExtensionFactory {
+
+	@Override
+	protected Bundle getBundle() {
+		return org.eclipse.papyrus.alf.ui.internal.AlfActivator.getInstance().getBundle();
+	}
+	
+	@Override
+	protected Injector getInjector() {
+		return org.eclipse.papyrus.alf.ui.internal.AlfActivator.getInstance().getInjector("org.eclipse.papyrus.alf.Alf");
+	}
+	
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/AbstractAlfProposalProvider.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/AbstractAlfProposalProvider.java
new file mode 100644
index 00000000000..9f5a992db81
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/AbstractAlfProposalProvider.java
@@ -0,0 +1,908 @@
+/*
+* generated by Xtext
+*/
+package org.eclipse.papyrus.alf.ui.contentassist;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.common.ui.contentassist.TerminalsProposalProvider;
+import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor;
+import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext;
+
+/**
+ * Represents a generated, default implementation of interface {@link IProposalProvider}.
+ * Methods are dynamically dispatched on the first parameter, i.e., you can override them 
+ * with a more concrete subtype. 
+ */
+@SuppressWarnings("all")
+public class AbstractAlfProposalProvider extends TerminalsProposalProvider {
+		
+	public void completeTest_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeTest_AssignExpression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeTest_Statements(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeTest_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeBOOLEAN_LITERAL_Value(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeINTEGER_LITERAL_Value(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeUNLIMITED_LITERAL_Value(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void completeSTRING_LITERAL_Value(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeNameExpression_PrefixOp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+		// subclasses may override
+	}
+	public void completeNameExpression_Path(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeNameExpression_Id(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeNameExpression_InvocationCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeNameExpression_SequenceConstructionCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeNameExpression_PostfixOp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+		// subclasses may override
+	}
+	public void completeNameExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeQualifiedNamePath_Namespace(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeUnqualifiedName_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeUnqualifiedName_TemplateBinding(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeTemplateBinding_Bindings(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeNamedTemplateBinding_Formal(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeNamedTemplateBinding_Actual(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeQualifiedNameWithBinding_Id(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeQualifiedNameWithBinding_Binding(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeQualifiedNameWithBinding_Remaining(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeTuple_TupleElements(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeTupleElement_Argument(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeConditionalTestExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeConditionalTestExpression_WhenTrue(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeConditionalTestExpression_WhenFalse(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeConditionalOrExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeConditionalAndExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeInclusiveOrExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeExclusiveOrExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAndExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeEqualityExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeEqualityExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+		// subclasses may override
+	}
+	public void completeClassificationExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeClassificationExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+		// subclasses may override
+	}
+	public void completeClassificationExpression_TypeName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeRelationalExpression_Left(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeRelationalExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+		// subclasses may override
+		// subclasses may override
+		// subclasses may override
+	}
+	public void completeRelationalExpression_Right(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeShiftExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeShiftExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+		// subclasses may override
+		// subclasses may override
+	}
+	public void completeAdditiveExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAdditiveExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+		// subclasses may override
+	}
+	public void completeMultiplicativeExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeMultiplicativeExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+		// subclasses may override
+		// subclasses may override
+	}
+	public void completeUnaryExpression_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+		// subclasses may override
+		// subclasses may override
+		// subclasses may override
+		// subclasses may override
+	}
+	public void completeUnaryExpression_Exp(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completePrimaryExpression_Prefix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeOperationCallExpression_OperationName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeOperationCallExpression_Tuple(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeOperationCallExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completePropertyCallExpression_PropertyName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completePropertyCallExpression_Index(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completePropertyCallExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLinkOperationExpression_Kind(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLinkOperationExpression_Tuple(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLinkOperationTuple_LinkOperationTupleElement(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLinkOperationTupleElement_Role(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLinkOperationTupleElement_RoleIndex(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLinkOperationTupleElement_Object(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSequenceOperationExpression_OperationName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSequenceOperationExpression_Tuple(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSequenceOperationExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSequenceReductionExpression_IsOrdered(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void completeSequenceReductionExpression_Behavior(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSequenceReductionExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSelectOrRejectOperation_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSelectOrRejectOperation_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSelectOrRejectOperation_Expr(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSelectOrRejectOperation_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeCollectOrIterateOperation_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeCollectOrIterateOperation_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeCollectOrIterateOperation_Expr(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeCollectOrIterateOperation_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeForAllOrExistsOrOneOperation_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeForAllOrExistsOrOneOperation_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeForAllOrExistsOrOneOperation_Expr(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeForAllOrExistsOrOneOperation_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeIsUniqueOperation_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeIsUniqueOperation_Expr(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeIsUniqueOperation_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeParenthesizedExpression_ExpOrTypeCast(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeParenthesizedExpression_Casted(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeParenthesizedExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeThisExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSuperInvocationExpression_Tuple(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSuperInvocationExpression_OperationName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeInstanceCreationExpression_Constructor(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeInstanceCreationExpression_Tuple(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeInstanceCreationExpression_Suffix(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeInstanceCreationTuple_InstanceCreationTupleElement(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeInstanceCreationTupleElement_Role(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeInstanceCreationTupleElement_Object(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSequenceConstructionOrAccessCompletion_MultiplicityIndicator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void completeSequenceConstructionOrAccessCompletion_AccessCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSequenceConstructionOrAccessCompletion_SequenceCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSequenceConstructionOrAccessCompletion_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAccessCompletion_AccessIndex(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completePartialSequenceConstructionCompletion_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSequenceConstructionExpression_SequenceElement(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSequenceConstructionExpression_RangeUpper(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeBlock_Sequence(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeStatementSequence_Statements(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeDocumentedStatement_Comment(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)((Alternatives)assignment.getTerminal()).getElements().get(0)), context, acceptor);
+		completeRuleCall(((RuleCall)((Alternatives)assignment.getTerminal()).getElements().get(1)), context, acceptor);
+	}
+	public void completeDocumentedStatement_Statement(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeInlineStatement_LangageName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeInlineStatement_Body(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAnnotatedStatement_Annotation(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAnnotatedStatement_Statement(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAnnotation_Kind(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAnnotation_Args(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeBlockStatement_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLocalNameDeclarationStatement_VarName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLocalNameDeclarationStatement_Type(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLocalNameDeclarationStatement_MultiplicityIndicator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void completeLocalNameDeclarationStatement_Init(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeIfStatement_SequentialClausses(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeIfStatement_FinalClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSequentialClauses_ConccurentClauses(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeConcurrentClauses_NonFinalClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeNonFinalClause_Condition(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeNonFinalClause_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeFinalClause_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSwitchStatement_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSwitchStatement_SwitchClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSwitchStatement_DefaultClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSwitchClause_SwitchCase(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSwitchClause_StatementSequence(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSwitchCase_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSwitchDefaultClause_StatementSequence(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeNonEmptyStatementSequence_Statement(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeWhileStatement_Condition(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeWhileStatement_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeDoStatement_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeDoStatement_Condition(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeForStatement_Control(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeForStatement_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeForControl_LoopVariableDefinition(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLoopVariableDefinition_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLoopVariableDefinition_Expression1(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLoopVariableDefinition_Expression2(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLoopVariableDefinition_Type(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeLoopVariableDefinition_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeReturnStatement_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAcceptStatement_Clause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAcceptStatement_SimpleAccept(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAcceptStatement_CompoundAccept(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeCompoundAcceptStatementCompletion_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeCompoundAcceptStatementCompletion_AcceptBlock(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAcceptBlock_Clause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAcceptBlock_Block(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAcceptClause_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAcceptClause_QualifiedNameList(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeClassifyStatement_Expression(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeClassifyStatement_Clause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeClassificationClause_ClassifyFromClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeClassificationClause_ClassifyToClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeClassificationClause_ReclassyAllClause(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeClassificationFromClause_QualifiedNameList(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeClassificationToClause_QualifiedNameList(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeQualifiedNameList_QualifiedName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeInvocationOrAssignementOrDeclarationStatement_TypePart_OR_assignedPart_OR_invocationPart(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeInvocationOrAssignementOrDeclarationStatement_VariableDeclarationCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeInvocationOrAssignementOrDeclarationStatement_AssignmentCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeSuperInvocationStatement__super(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeThisInvocationStatement__this(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeThisInvocationStatement_AssignmentCompletion(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeInstanceCreationInvocationStatement__new(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeVariableDeclarationCompletion_MultiplicityIndicator(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void completeVariableDeclarationCompletion_VariableName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeVariableDeclarationCompletion_InitValue(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAssignmentCompletion_Op(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+	public void completeAssignmentCompletion_RightHandSide(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+    
+	public void complete_Test(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_LITERAL(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_BOOLEAN_LITERAL(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_BooleanValue(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_NUMBER_LITERAL(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_INTEGER_LITERAL(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_UNLIMITED_LITERAL(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_IntegerValue(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_STRING_LITERAL(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_NameExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_QualifiedNamePath(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_UnqualifiedName(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_TemplateBinding(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_NamedTemplateBinding(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_QualifiedNameWithBinding(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_Tuple(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_TupleElement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_Expression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ConditionalTestExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ConditionalOrExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ConditionalAndExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_InclusiveOrExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ExclusiveOrExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_AndExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_EqualityExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ClassificationExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_RelationalExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ShiftExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_AdditiveExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_MultiplicativeExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_UnaryExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_PrimaryExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SuffixExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_OperationCallExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_PropertyCallExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_LinkOperationExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_LinkOperationTuple(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_LinkOperationTupleElement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_LinkOperationKind(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SequenceOperationExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SequenceReductionExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SequenceExpansionExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SelectOrRejectOperation(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SelectOrRejectOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_CollectOrIterateOperation(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_CollectOrIterateOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ForAllOrExistsOrOneOperation(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ForAllOrExistsOrOneOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_IsUniqueOperation(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ValueSpecification(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_NonLiteralValueSpecification(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ParenthesizedExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_NullExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ThisExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SuperInvocationExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_InstanceCreationExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_InstanceCreationTuple(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_InstanceCreationTupleElement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SequenceConstructionOrAccessCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_AccessCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_PartialSequenceConstructionCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SequenceConstructionExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SequenceElement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ClassExtentExpression(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_Block(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_StatementSequence(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_DocumentedStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_InlineStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_AnnotatedStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_Statement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_Annotation(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_AnnotationKind(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_BlockStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_EmptyStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_LocalNameDeclarationStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_IfStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SequentialClauses(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ConcurrentClauses(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_NonFinalClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_FinalClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SwitchStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SwitchClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SwitchCase(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SwitchDefaultClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_NonEmptyStatementSequence(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_WhileStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_DoStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ForStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ForControl(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_LoopVariableDefinition(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_BreakStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ReturnStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_AcceptStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SimpleAcceptStatementCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_CompoundAcceptStatementCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_AcceptBlock(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_AcceptClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ClassifyStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ClassificationClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ClassificationFromClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ClassificationToClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ReclassifyAllClause(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_QualifiedNameList(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_InvocationOrAssignementOrDeclarationStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SuperInvocationStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ThisInvocationStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_InstanceCreationInvocationStatement(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_VariableDeclarationCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_AssignmentCompletion(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_AssignmentOperator(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ID(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_STRING(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_ML_COMMENT(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void complete_SL_COMMENT(EObject model, RuleCall ruleCall, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/AlfParser.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/AlfParser.java
new file mode 100644
index 00000000000..690f751643c
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/AlfParser.java
@@ -0,0 +1,433 @@
+/*
+* generated by Xtext
+*/
+package org.eclipse.papyrus.alf.ui.contentassist.antlr;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.HashMap;
+
+import org.antlr.runtime.RecognitionException;
+import org.eclipse.xtext.AbstractElement;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.AbstractContentAssistParser;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.FollowElement;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+
+import com.google.inject.Inject;
+
+import org.eclipse.papyrus.alf.services.AlfGrammarAccess;
+
+public class AlfParser extends AbstractContentAssistParser {
+	
+	@Inject
+	private AlfGrammarAccess grammarAccess;
+	
+	private Map<AbstractElement, String> nameMappings;
+	
+	@Override
+	protected org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfParser createParser() {
+		org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfParser result = new org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfParser(null);
+		result.setGrammarAccess(grammarAccess);
+		return result;
+	}
+	
+	@Override
+	protected String getRuleName(AbstractElement element) {
+		if (nameMappings == null) {
+			nameMappings = new HashMap<AbstractElement, String>() {
+				private static final long serialVersionUID = 1L;
+				{
+					put(grammarAccess.getLITERALAccess().getAlternatives(), "rule__LITERAL__Alternatives");
+					put(grammarAccess.getNUMBER_LITERALAccess().getAlternatives(), "rule__NUMBER_LITERAL__Alternatives");
+					put(grammarAccess.getNameExpressionAccess().getAlternatives_0(), "rule__NameExpression__Alternatives_0");
+					put(grammarAccess.getNameExpressionAccess().getPrefixOpAlternatives_0_0_0_0(), "rule__NameExpression__PrefixOpAlternatives_0_0_0_0");
+					put(grammarAccess.getNameExpressionAccess().getAlternatives_0_1_2(), "rule__NameExpression__Alternatives_0_1_2");
+					put(grammarAccess.getNameExpressionAccess().getPostfixOpAlternatives_0_1_2_2_0(), "rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0");
+					put(grammarAccess.getEqualityExpressionAccess().getOpAlternatives_1_0_0(), "rule__EqualityExpression__OpAlternatives_1_0_0");
+					put(grammarAccess.getClassificationExpressionAccess().getOpAlternatives_1_0_0(), "rule__ClassificationExpression__OpAlternatives_1_0_0");
+					put(grammarAccess.getRelationalExpressionAccess().getOpAlternatives_1_0_0(), "rule__RelationalExpression__OpAlternatives_1_0_0");
+					put(grammarAccess.getShiftExpressionAccess().getOpAlternatives_1_0_0(), "rule__ShiftExpression__OpAlternatives_1_0_0");
+					put(grammarAccess.getAdditiveExpressionAccess().getOpAlternatives_1_0_0(), "rule__AdditiveExpression__OpAlternatives_1_0_0");
+					put(grammarAccess.getMultiplicativeExpressionAccess().getOpAlternatives_1_0_0(), "rule__MultiplicativeExpression__OpAlternatives_1_0_0");
+					put(grammarAccess.getUnaryExpressionAccess().getOpAlternatives_0_0(), "rule__UnaryExpression__OpAlternatives_0_0");
+					put(grammarAccess.getSuffixExpressionAccess().getAlternatives(), "rule__SuffixExpression__Alternatives");
+					put(grammarAccess.getSequenceExpansionExpressionAccess().getAlternatives(), "rule__SequenceExpansionExpression__Alternatives");
+					put(grammarAccess.getValueSpecificationAccess().getAlternatives(), "rule__ValueSpecification__Alternatives");
+					put(grammarAccess.getNonLiteralValueSpecificationAccess().getAlternatives(), "rule__NonLiteralValueSpecification__Alternatives");
+					put(grammarAccess.getParenthesizedExpressionAccess().getAlternatives_3(), "rule__ParenthesizedExpression__Alternatives_3");
+					put(grammarAccess.getSuperInvocationExpressionAccess().getAlternatives_1(), "rule__SuperInvocationExpression__Alternatives_1");
+					put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives(), "rule__SequenceConstructionOrAccessCompletion__Alternatives");
+					put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives_0_1(), "rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1");
+					put(grammarAccess.getSequenceConstructionExpressionAccess().getAlternatives_2(), "rule__SequenceConstructionExpression__Alternatives_2");
+					put(grammarAccess.getSequenceElementAccess().getAlternatives(), "rule__SequenceElement__Alternatives");
+					put(grammarAccess.getDocumentedStatementAccess().getCommentAlternatives_0_0(), "rule__DocumentedStatement__CommentAlternatives_0_0");
+					put(grammarAccess.getStatementAccess().getAlternatives(), "rule__Statement__Alternatives");
+					put(grammarAccess.getLoopVariableDefinitionAccess().getAlternatives(), "rule__LoopVariableDefinition__Alternatives");
+					put(grammarAccess.getAcceptStatementAccess().getAlternatives_1(), "rule__AcceptStatement__Alternatives_1");
+					put(grammarAccess.getClassificationClauseAccess().getAlternatives(), "rule__ClassificationClause__Alternatives");
+					put(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAlternatives_1(), "rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1");
+					put(grammarAccess.getBooleanValueAccess().getAlternatives(), "rule__BooleanValue__Alternatives");
+					put(grammarAccess.getLinkOperationKindAccess().getAlternatives(), "rule__LinkOperationKind__Alternatives");
+					put(grammarAccess.getSelectOrRejectOperatorAccess().getAlternatives(), "rule__SelectOrRejectOperator__Alternatives");
+					put(grammarAccess.getCollectOrIterateOperatorAccess().getAlternatives(), "rule__CollectOrIterateOperator__Alternatives");
+					put(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getAlternatives(), "rule__ForAllOrExistsOrOneOperator__Alternatives");
+					put(grammarAccess.getAnnotationKindAccess().getAlternatives(), "rule__AnnotationKind__Alternatives");
+					put(grammarAccess.getAssignmentOperatorAccess().getAlternatives(), "rule__AssignmentOperator__Alternatives");
+					put(grammarAccess.getTestAccess().getGroup(), "rule__Test__Group__0");
+					put(grammarAccess.getTestAccess().getGroup_0(), "rule__Test__Group_0__0");
+					put(grammarAccess.getTestAccess().getGroup_1(), "rule__Test__Group_1__0");
+					put(grammarAccess.getTestAccess().getGroup_2(), "rule__Test__Group_2__0");
+					put(grammarAccess.getTestAccess().getGroup_3(), "rule__Test__Group_3__0");
+					put(grammarAccess.getNameExpressionAccess().getGroup(), "rule__NameExpression__Group__0");
+					put(grammarAccess.getNameExpressionAccess().getGroup_0_0(), "rule__NameExpression__Group_0_0__0");
+					put(grammarAccess.getNameExpressionAccess().getGroup_0_1(), "rule__NameExpression__Group_0_1__0");
+					put(grammarAccess.getQualifiedNamePathAccess().getGroup(), "rule__QualifiedNamePath__Group__0");
+					put(grammarAccess.getUnqualifiedNameAccess().getGroup(), "rule__UnqualifiedName__Group__0");
+					put(grammarAccess.getTemplateBindingAccess().getGroup(), "rule__TemplateBinding__Group__0");
+					put(grammarAccess.getTemplateBindingAccess().getGroup_2(), "rule__TemplateBinding__Group_2__0");
+					put(grammarAccess.getNamedTemplateBindingAccess().getGroup(), "rule__NamedTemplateBinding__Group__0");
+					put(grammarAccess.getQualifiedNameWithBindingAccess().getGroup(), "rule__QualifiedNameWithBinding__Group__0");
+					put(grammarAccess.getQualifiedNameWithBindingAccess().getGroup_2(), "rule__QualifiedNameWithBinding__Group_2__0");
+					put(grammarAccess.getTupleAccess().getGroup(), "rule__Tuple__Group__0");
+					put(grammarAccess.getTupleAccess().getGroup_2(), "rule__Tuple__Group_2__0");
+					put(grammarAccess.getTupleAccess().getGroup_2_1(), "rule__Tuple__Group_2_1__0");
+					put(grammarAccess.getConditionalTestExpressionAccess().getGroup(), "rule__ConditionalTestExpression__Group__0");
+					put(grammarAccess.getConditionalTestExpressionAccess().getGroup_1(), "rule__ConditionalTestExpression__Group_1__0");
+					put(grammarAccess.getConditionalOrExpressionAccess().getGroup(), "rule__ConditionalOrExpression__Group__0");
+					put(grammarAccess.getConditionalOrExpressionAccess().getGroup_1(), "rule__ConditionalOrExpression__Group_1__0");
+					put(grammarAccess.getConditionalAndExpressionAccess().getGroup(), "rule__ConditionalAndExpression__Group__0");
+					put(grammarAccess.getConditionalAndExpressionAccess().getGroup_1(), "rule__ConditionalAndExpression__Group_1__0");
+					put(grammarAccess.getInclusiveOrExpressionAccess().getGroup(), "rule__InclusiveOrExpression__Group__0");
+					put(grammarAccess.getInclusiveOrExpressionAccess().getGroup_1(), "rule__InclusiveOrExpression__Group_1__0");
+					put(grammarAccess.getExclusiveOrExpressionAccess().getGroup(), "rule__ExclusiveOrExpression__Group__0");
+					put(grammarAccess.getExclusiveOrExpressionAccess().getGroup_1(), "rule__ExclusiveOrExpression__Group_1__0");
+					put(grammarAccess.getAndExpressionAccess().getGroup(), "rule__AndExpression__Group__0");
+					put(grammarAccess.getAndExpressionAccess().getGroup_1(), "rule__AndExpression__Group_1__0");
+					put(grammarAccess.getEqualityExpressionAccess().getGroup(), "rule__EqualityExpression__Group__0");
+					put(grammarAccess.getEqualityExpressionAccess().getGroup_1(), "rule__EqualityExpression__Group_1__0");
+					put(grammarAccess.getClassificationExpressionAccess().getGroup(), "rule__ClassificationExpression__Group__0");
+					put(grammarAccess.getClassificationExpressionAccess().getGroup_1(), "rule__ClassificationExpression__Group_1__0");
+					put(grammarAccess.getRelationalExpressionAccess().getGroup(), "rule__RelationalExpression__Group__0");
+					put(grammarAccess.getRelationalExpressionAccess().getGroup_1(), "rule__RelationalExpression__Group_1__0");
+					put(grammarAccess.getShiftExpressionAccess().getGroup(), "rule__ShiftExpression__Group__0");
+					put(grammarAccess.getShiftExpressionAccess().getGroup_1(), "rule__ShiftExpression__Group_1__0");
+					put(grammarAccess.getAdditiveExpressionAccess().getGroup(), "rule__AdditiveExpression__Group__0");
+					put(grammarAccess.getAdditiveExpressionAccess().getGroup_1(), "rule__AdditiveExpression__Group_1__0");
+					put(grammarAccess.getMultiplicativeExpressionAccess().getGroup(), "rule__MultiplicativeExpression__Group__0");
+					put(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1(), "rule__MultiplicativeExpression__Group_1__0");
+					put(grammarAccess.getUnaryExpressionAccess().getGroup(), "rule__UnaryExpression__Group__0");
+					put(grammarAccess.getOperationCallExpressionAccess().getGroup(), "rule__OperationCallExpression__Group__0");
+					put(grammarAccess.getPropertyCallExpressionAccess().getGroup(), "rule__PropertyCallExpression__Group__0");
+					put(grammarAccess.getPropertyCallExpressionAccess().getGroup_2(), "rule__PropertyCallExpression__Group_2__0");
+					put(grammarAccess.getLinkOperationExpressionAccess().getGroup(), "rule__LinkOperationExpression__Group__0");
+					put(grammarAccess.getLinkOperationTupleAccess().getGroup(), "rule__LinkOperationTuple__Group__0");
+					put(grammarAccess.getLinkOperationTupleAccess().getGroup_2(), "rule__LinkOperationTuple__Group_2__0");
+					put(grammarAccess.getLinkOperationTupleElementAccess().getGroup(), "rule__LinkOperationTupleElement__Group__0");
+					put(grammarAccess.getLinkOperationTupleElementAccess().getGroup_1(), "rule__LinkOperationTupleElement__Group_1__0");
+					put(grammarAccess.getSequenceOperationExpressionAccess().getGroup(), "rule__SequenceOperationExpression__Group__0");
+					put(grammarAccess.getSequenceReductionExpressionAccess().getGroup(), "rule__SequenceReductionExpression__Group__0");
+					put(grammarAccess.getSelectOrRejectOperationAccess().getGroup(), "rule__SelectOrRejectOperation__Group__0");
+					put(grammarAccess.getCollectOrIterateOperationAccess().getGroup(), "rule__CollectOrIterateOperation__Group__0");
+					put(grammarAccess.getForAllOrExistsOrOneOperationAccess().getGroup(), "rule__ForAllOrExistsOrOneOperation__Group__0");
+					put(grammarAccess.getIsUniqueOperationAccess().getGroup(), "rule__IsUniqueOperation__Group__0");
+					put(grammarAccess.getParenthesizedExpressionAccess().getGroup(), "rule__ParenthesizedExpression__Group__0");
+					put(grammarAccess.getNullExpressionAccess().getGroup(), "rule__NullExpression__Group__0");
+					put(grammarAccess.getThisExpressionAccess().getGroup(), "rule__ThisExpression__Group__0");
+					put(grammarAccess.getSuperInvocationExpressionAccess().getGroup(), "rule__SuperInvocationExpression__Group__0");
+					put(grammarAccess.getSuperInvocationExpressionAccess().getGroup_1_1(), "rule__SuperInvocationExpression__Group_1_1__0");
+					put(grammarAccess.getInstanceCreationExpressionAccess().getGroup(), "rule__InstanceCreationExpression__Group__0");
+					put(grammarAccess.getInstanceCreationTupleAccess().getGroup(), "rule__InstanceCreationTuple__Group__0");
+					put(grammarAccess.getInstanceCreationTupleAccess().getGroup_2(), "rule__InstanceCreationTuple__Group_2__0");
+					put(grammarAccess.getInstanceCreationTupleAccess().getGroup_2_1(), "rule__InstanceCreationTuple__Group_2_1__0");
+					put(grammarAccess.getInstanceCreationTupleElementAccess().getGroup(), "rule__InstanceCreationTupleElement__Group__0");
+					put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getGroup_0(), "rule__SequenceConstructionOrAccessCompletion__Group_0__0");
+					put(grammarAccess.getAccessCompletionAccess().getGroup(), "rule__AccessCompletion__Group__0");
+					put(grammarAccess.getPartialSequenceConstructionCompletionAccess().getGroup(), "rule__PartialSequenceConstructionCompletion__Group__0");
+					put(grammarAccess.getSequenceConstructionExpressionAccess().getGroup(), "rule__SequenceConstructionExpression__Group__0");
+					put(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_0(), "rule__SequenceConstructionExpression__Group_2_0__0");
+					put(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_1(), "rule__SequenceConstructionExpression__Group_2_1__0");
+					put(grammarAccess.getClassExtentExpressionAccess().getGroup(), "rule__ClassExtentExpression__Group__0");
+					put(grammarAccess.getBlockAccess().getGroup(), "rule__Block__Group__0");
+					put(grammarAccess.getDocumentedStatementAccess().getGroup(), "rule__DocumentedStatement__Group__0");
+					put(grammarAccess.getInlineStatementAccess().getGroup(), "rule__InlineStatement__Group__0");
+					put(grammarAccess.getAnnotatedStatementAccess().getGroup(), "rule__AnnotatedStatement__Group__0");
+					put(grammarAccess.getAnnotationAccess().getGroup(), "rule__Annotation__Group__0");
+					put(grammarAccess.getAnnotationAccess().getGroup_1(), "rule__Annotation__Group_1__0");
+					put(grammarAccess.getAnnotationAccess().getGroup_1_2(), "rule__Annotation__Group_1_2__0");
+					put(grammarAccess.getEmptyStatementAccess().getGroup(), "rule__EmptyStatement__Group__0");
+					put(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup(), "rule__LocalNameDeclarationStatement__Group__0");
+					put(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup_4(), "rule__LocalNameDeclarationStatement__Group_4__0");
+					put(grammarAccess.getIfStatementAccess().getGroup(), "rule__IfStatement__Group__0");
+					put(grammarAccess.getSequentialClausesAccess().getGroup(), "rule__SequentialClauses__Group__0");
+					put(grammarAccess.getSequentialClausesAccess().getGroup_1(), "rule__SequentialClauses__Group_1__0");
+					put(grammarAccess.getConcurrentClausesAccess().getGroup(), "rule__ConcurrentClauses__Group__0");
+					put(grammarAccess.getConcurrentClausesAccess().getGroup_1(), "rule__ConcurrentClauses__Group_1__0");
+					put(grammarAccess.getNonFinalClauseAccess().getGroup(), "rule__NonFinalClause__Group__0");
+					put(grammarAccess.getFinalClauseAccess().getGroup(), "rule__FinalClause__Group__0");
+					put(grammarAccess.getSwitchStatementAccess().getGroup(), "rule__SwitchStatement__Group__0");
+					put(grammarAccess.getSwitchClauseAccess().getGroup(), "rule__SwitchClause__Group__0");
+					put(grammarAccess.getSwitchCaseAccess().getGroup(), "rule__SwitchCase__Group__0");
+					put(grammarAccess.getSwitchDefaultClauseAccess().getGroup(), "rule__SwitchDefaultClause__Group__0");
+					put(grammarAccess.getWhileStatementAccess().getGroup(), "rule__WhileStatement__Group__0");
+					put(grammarAccess.getDoStatementAccess().getGroup(), "rule__DoStatement__Group__0");
+					put(grammarAccess.getForStatementAccess().getGroup(), "rule__ForStatement__Group__0");
+					put(grammarAccess.getForControlAccess().getGroup(), "rule__ForControl__Group__0");
+					put(grammarAccess.getForControlAccess().getGroup_1(), "rule__ForControl__Group_1__0");
+					put(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0(), "rule__LoopVariableDefinition__Group_0__0");
+					put(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0_3(), "rule__LoopVariableDefinition__Group_0_3__0");
+					put(grammarAccess.getLoopVariableDefinitionAccess().getGroup_1(), "rule__LoopVariableDefinition__Group_1__0");
+					put(grammarAccess.getBreakStatementAccess().getGroup(), "rule__BreakStatement__Group__0");
+					put(grammarAccess.getReturnStatementAccess().getGroup(), "rule__ReturnStatement__Group__0");
+					put(grammarAccess.getAcceptStatementAccess().getGroup(), "rule__AcceptStatement__Group__0");
+					put(grammarAccess.getSimpleAcceptStatementCompletionAccess().getGroup(), "rule__SimpleAcceptStatementCompletion__Group__0");
+					put(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup(), "rule__CompoundAcceptStatementCompletion__Group__0");
+					put(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup_1(), "rule__CompoundAcceptStatementCompletion__Group_1__0");
+					put(grammarAccess.getAcceptBlockAccess().getGroup(), "rule__AcceptBlock__Group__0");
+					put(grammarAccess.getAcceptClauseAccess().getGroup(), "rule__AcceptClause__Group__0");
+					put(grammarAccess.getAcceptClauseAccess().getGroup_2(), "rule__AcceptClause__Group_2__0");
+					put(grammarAccess.getClassifyStatementAccess().getGroup(), "rule__ClassifyStatement__Group__0");
+					put(grammarAccess.getClassificationClauseAccess().getGroup_0(), "rule__ClassificationClause__Group_0__0");
+					put(grammarAccess.getClassificationClauseAccess().getGroup_1(), "rule__ClassificationClause__Group_1__0");
+					put(grammarAccess.getClassificationFromClauseAccess().getGroup(), "rule__ClassificationFromClause__Group__0");
+					put(grammarAccess.getClassificationToClauseAccess().getGroup(), "rule__ClassificationToClause__Group__0");
+					put(grammarAccess.getReclassifyAllClauseAccess().getGroup(), "rule__ReclassifyAllClause__Group__0");
+					put(grammarAccess.getQualifiedNameListAccess().getGroup(), "rule__QualifiedNameList__Group__0");
+					put(grammarAccess.getQualifiedNameListAccess().getGroup_1(), "rule__QualifiedNameList__Group_1__0");
+					put(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getGroup(), "rule__InvocationOrAssignementOrDeclarationStatement__Group__0");
+					put(grammarAccess.getSuperInvocationStatementAccess().getGroup(), "rule__SuperInvocationStatement__Group__0");
+					put(grammarAccess.getThisInvocationStatementAccess().getGroup(), "rule__ThisInvocationStatement__Group__0");
+					put(grammarAccess.getInstanceCreationInvocationStatementAccess().getGroup(), "rule__InstanceCreationInvocationStatement__Group__0");
+					put(grammarAccess.getVariableDeclarationCompletionAccess().getGroup(), "rule__VariableDeclarationCompletion__Group__0");
+					put(grammarAccess.getVariableDeclarationCompletionAccess().getGroup_0(), "rule__VariableDeclarationCompletion__Group_0__0");
+					put(grammarAccess.getAssignmentCompletionAccess().getGroup(), "rule__AssignmentCompletion__Group__0");
+					put(grammarAccess.getTestAccess().getExpressionAssignment_0_1(), "rule__Test__ExpressionAssignment_0_1");
+					put(grammarAccess.getTestAccess().getAssignExpressionAssignment_1_1(), "rule__Test__AssignExpressionAssignment_1_1");
+					put(grammarAccess.getTestAccess().getStatementsAssignment_2_1(), "rule__Test__StatementsAssignment_2_1");
+					put(grammarAccess.getTestAccess().getBlockAssignment_3_1(), "rule__Test__BlockAssignment_3_1");
+					put(grammarAccess.getBOOLEAN_LITERALAccess().getValueAssignment(), "rule__BOOLEAN_LITERAL__ValueAssignment");
+					put(grammarAccess.getINTEGER_LITERALAccess().getValueAssignment(), "rule__INTEGER_LITERAL__ValueAssignment");
+					put(grammarAccess.getUNLIMITED_LITERALAccess().getValueAssignment(), "rule__UNLIMITED_LITERAL__ValueAssignment");
+					put(grammarAccess.getSTRING_LITERALAccess().getValueAssignment(), "rule__STRING_LITERAL__ValueAssignment");
+					put(grammarAccess.getNameExpressionAccess().getPrefixOpAssignment_0_0_0(), "rule__NameExpression__PrefixOpAssignment_0_0_0");
+					put(grammarAccess.getNameExpressionAccess().getPathAssignment_0_0_1(), "rule__NameExpression__PathAssignment_0_0_1");
+					put(grammarAccess.getNameExpressionAccess().getIdAssignment_0_0_2(), "rule__NameExpression__IdAssignment_0_0_2");
+					put(grammarAccess.getNameExpressionAccess().getPathAssignment_0_1_0(), "rule__NameExpression__PathAssignment_0_1_0");
+					put(grammarAccess.getNameExpressionAccess().getIdAssignment_0_1_1(), "rule__NameExpression__IdAssignment_0_1_1");
+					put(grammarAccess.getNameExpressionAccess().getInvocationCompletionAssignment_0_1_2_0(), "rule__NameExpression__InvocationCompletionAssignment_0_1_2_0");
+					put(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionAssignment_0_1_2_1(), "rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1");
+					put(grammarAccess.getNameExpressionAccess().getPostfixOpAssignment_0_1_2_2(), "rule__NameExpression__PostfixOpAssignment_0_1_2_2");
+					put(grammarAccess.getNameExpressionAccess().getSuffixAssignment_1(), "rule__NameExpression__SuffixAssignment_1");
+					put(grammarAccess.getQualifiedNamePathAccess().getNamespaceAssignment_0(), "rule__QualifiedNamePath__NamespaceAssignment_0");
+					put(grammarAccess.getUnqualifiedNameAccess().getNameAssignment_0(), "rule__UnqualifiedName__NameAssignment_0");
+					put(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingAssignment_1(), "rule__UnqualifiedName__TemplateBindingAssignment_1");
+					put(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_1(), "rule__TemplateBinding__BindingsAssignment_1");
+					put(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_2_1(), "rule__TemplateBinding__BindingsAssignment_2_1");
+					put(grammarAccess.getNamedTemplateBindingAccess().getFormalAssignment_0(), "rule__NamedTemplateBinding__FormalAssignment_0");
+					put(grammarAccess.getNamedTemplateBindingAccess().getActualAssignment_2(), "rule__NamedTemplateBinding__ActualAssignment_2");
+					put(grammarAccess.getQualifiedNameWithBindingAccess().getIdAssignment_0(), "rule__QualifiedNameWithBinding__IdAssignment_0");
+					put(grammarAccess.getQualifiedNameWithBindingAccess().getBindingAssignment_1(), "rule__QualifiedNameWithBinding__BindingAssignment_1");
+					put(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingAssignment_2_1(), "rule__QualifiedNameWithBinding__RemainingAssignment_2_1");
+					put(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_0(), "rule__Tuple__TupleElementsAssignment_2_0");
+					put(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_1_1(), "rule__Tuple__TupleElementsAssignment_2_1_1");
+					put(grammarAccess.getTupleElementAccess().getArgumentAssignment(), "rule__TupleElement__ArgumentAssignment");
+					put(grammarAccess.getConditionalTestExpressionAccess().getExpAssignment_0(), "rule__ConditionalTestExpression__ExpAssignment_0");
+					put(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueAssignment_1_1(), "rule__ConditionalTestExpression__WhenTrueAssignment_1_1");
+					put(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseAssignment_1_3(), "rule__ConditionalTestExpression__WhenFalseAssignment_1_3");
+					put(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_0(), "rule__ConditionalOrExpression__ExpAssignment_0");
+					put(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_1_1(), "rule__ConditionalOrExpression__ExpAssignment_1_1");
+					put(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_0(), "rule__ConditionalAndExpression__ExpAssignment_0");
+					put(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_1_1(), "rule__ConditionalAndExpression__ExpAssignment_1_1");
+					put(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_0(), "rule__InclusiveOrExpression__ExpAssignment_0");
+					put(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_1_1(), "rule__InclusiveOrExpression__ExpAssignment_1_1");
+					put(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_0(), "rule__ExclusiveOrExpression__ExpAssignment_0");
+					put(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_1_1(), "rule__ExclusiveOrExpression__ExpAssignment_1_1");
+					put(grammarAccess.getAndExpressionAccess().getExpAssignment_0(), "rule__AndExpression__ExpAssignment_0");
+					put(grammarAccess.getAndExpressionAccess().getExpAssignment_1_1(), "rule__AndExpression__ExpAssignment_1_1");
+					put(grammarAccess.getEqualityExpressionAccess().getExpAssignment_0(), "rule__EqualityExpression__ExpAssignment_0");
+					put(grammarAccess.getEqualityExpressionAccess().getOpAssignment_1_0(), "rule__EqualityExpression__OpAssignment_1_0");
+					put(grammarAccess.getEqualityExpressionAccess().getExpAssignment_1_1(), "rule__EqualityExpression__ExpAssignment_1_1");
+					put(grammarAccess.getClassificationExpressionAccess().getExpAssignment_0(), "rule__ClassificationExpression__ExpAssignment_0");
+					put(grammarAccess.getClassificationExpressionAccess().getOpAssignment_1_0(), "rule__ClassificationExpression__OpAssignment_1_0");
+					put(grammarAccess.getClassificationExpressionAccess().getTypeNameAssignment_1_1(), "rule__ClassificationExpression__TypeNameAssignment_1_1");
+					put(grammarAccess.getRelationalExpressionAccess().getLeftAssignment_0(), "rule__RelationalExpression__LeftAssignment_0");
+					put(grammarAccess.getRelationalExpressionAccess().getOpAssignment_1_0(), "rule__RelationalExpression__OpAssignment_1_0");
+					put(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_1(), "rule__RelationalExpression__RightAssignment_1_1");
+					put(grammarAccess.getShiftExpressionAccess().getExpAssignment_0(), "rule__ShiftExpression__ExpAssignment_0");
+					put(grammarAccess.getShiftExpressionAccess().getOpAssignment_1_0(), "rule__ShiftExpression__OpAssignment_1_0");
+					put(grammarAccess.getShiftExpressionAccess().getExpAssignment_1_1(), "rule__ShiftExpression__ExpAssignment_1_1");
+					put(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_0(), "rule__AdditiveExpression__ExpAssignment_0");
+					put(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_0(), "rule__AdditiveExpression__OpAssignment_1_0");
+					put(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_1_1(), "rule__AdditiveExpression__ExpAssignment_1_1");
+					put(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_0(), "rule__MultiplicativeExpression__ExpAssignment_0");
+					put(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_0(), "rule__MultiplicativeExpression__OpAssignment_1_0");
+					put(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_1_1(), "rule__MultiplicativeExpression__ExpAssignment_1_1");
+					put(grammarAccess.getUnaryExpressionAccess().getOpAssignment_0(), "rule__UnaryExpression__OpAssignment_0");
+					put(grammarAccess.getUnaryExpressionAccess().getExpAssignment_1(), "rule__UnaryExpression__ExpAssignment_1");
+					put(grammarAccess.getPrimaryExpressionAccess().getPrefixAssignment(), "rule__PrimaryExpression__PrefixAssignment");
+					put(grammarAccess.getOperationCallExpressionAccess().getOperationNameAssignment_1(), "rule__OperationCallExpression__OperationNameAssignment_1");
+					put(grammarAccess.getOperationCallExpressionAccess().getTupleAssignment_2(), "rule__OperationCallExpression__TupleAssignment_2");
+					put(grammarAccess.getOperationCallExpressionAccess().getSuffixAssignment_3(), "rule__OperationCallExpression__SuffixAssignment_3");
+					put(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameAssignment_1(), "rule__PropertyCallExpression__PropertyNameAssignment_1");
+					put(grammarAccess.getPropertyCallExpressionAccess().getIndexAssignment_2_1(), "rule__PropertyCallExpression__IndexAssignment_2_1");
+					put(grammarAccess.getPropertyCallExpressionAccess().getSuffixAssignment_3(), "rule__PropertyCallExpression__SuffixAssignment_3");
+					put(grammarAccess.getLinkOperationExpressionAccess().getKindAssignment_1(), "rule__LinkOperationExpression__KindAssignment_1");
+					put(grammarAccess.getLinkOperationExpressionAccess().getTupleAssignment_2(), "rule__LinkOperationExpression__TupleAssignment_2");
+					put(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_1(), "rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1");
+					put(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_2_1(), "rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1");
+					put(grammarAccess.getLinkOperationTupleElementAccess().getRoleAssignment_0(), "rule__LinkOperationTupleElement__RoleAssignment_0");
+					put(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexAssignment_1_1(), "rule__LinkOperationTupleElement__RoleIndexAssignment_1_1");
+					put(grammarAccess.getLinkOperationTupleElementAccess().getObjectAssignment_3(), "rule__LinkOperationTupleElement__ObjectAssignment_3");
+					put(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameAssignment_1(), "rule__SequenceOperationExpression__OperationNameAssignment_1");
+					put(grammarAccess.getSequenceOperationExpressionAccess().getTupleAssignment_2(), "rule__SequenceOperationExpression__TupleAssignment_2");
+					put(grammarAccess.getSequenceOperationExpressionAccess().getSuffixAssignment_3(), "rule__SequenceOperationExpression__SuffixAssignment_3");
+					put(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedAssignment_2(), "rule__SequenceReductionExpression__IsOrderedAssignment_2");
+					put(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorAssignment_3(), "rule__SequenceReductionExpression__BehaviorAssignment_3");
+					put(grammarAccess.getSequenceReductionExpressionAccess().getSuffixAssignment_4(), "rule__SequenceReductionExpression__SuffixAssignment_4");
+					put(grammarAccess.getSelectOrRejectOperationAccess().getOpAssignment_1(), "rule__SelectOrRejectOperation__OpAssignment_1");
+					put(grammarAccess.getSelectOrRejectOperationAccess().getNameAssignment_2(), "rule__SelectOrRejectOperation__NameAssignment_2");
+					put(grammarAccess.getSelectOrRejectOperationAccess().getExprAssignment_4(), "rule__SelectOrRejectOperation__ExprAssignment_4");
+					put(grammarAccess.getSelectOrRejectOperationAccess().getSuffixAssignment_6(), "rule__SelectOrRejectOperation__SuffixAssignment_6");
+					put(grammarAccess.getCollectOrIterateOperationAccess().getOpAssignment_1(), "rule__CollectOrIterateOperation__OpAssignment_1");
+					put(grammarAccess.getCollectOrIterateOperationAccess().getNameAssignment_2(), "rule__CollectOrIterateOperation__NameAssignment_2");
+					put(grammarAccess.getCollectOrIterateOperationAccess().getExprAssignment_4(), "rule__CollectOrIterateOperation__ExprAssignment_4");
+					put(grammarAccess.getCollectOrIterateOperationAccess().getSuffixAssignment_6(), "rule__CollectOrIterateOperation__SuffixAssignment_6");
+					put(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpAssignment_1(), "rule__ForAllOrExistsOrOneOperation__OpAssignment_1");
+					put(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameAssignment_2(), "rule__ForAllOrExistsOrOneOperation__NameAssignment_2");
+					put(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprAssignment_4(), "rule__ForAllOrExistsOrOneOperation__ExprAssignment_4");
+					put(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixAssignment_6(), "rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6");
+					put(grammarAccess.getIsUniqueOperationAccess().getNameAssignment_2(), "rule__IsUniqueOperation__NameAssignment_2");
+					put(grammarAccess.getIsUniqueOperationAccess().getExprAssignment_4(), "rule__IsUniqueOperation__ExprAssignment_4");
+					put(grammarAccess.getIsUniqueOperationAccess().getSuffixAssignment_6(), "rule__IsUniqueOperation__SuffixAssignment_6");
+					put(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastAssignment_1(), "rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1");
+					put(grammarAccess.getParenthesizedExpressionAccess().getCastedAssignment_3_0(), "rule__ParenthesizedExpression__CastedAssignment_3_0");
+					put(grammarAccess.getParenthesizedExpressionAccess().getSuffixAssignment_3_1(), "rule__ParenthesizedExpression__SuffixAssignment_3_1");
+					put(grammarAccess.getThisExpressionAccess().getSuffixAssignment_2(), "rule__ThisExpression__SuffixAssignment_2");
+					put(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_0(), "rule__SuperInvocationExpression__TupleAssignment_1_0");
+					put(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameAssignment_1_1_1(), "rule__SuperInvocationExpression__OperationNameAssignment_1_1_1");
+					put(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_1_2(), "rule__SuperInvocationExpression__TupleAssignment_1_1_2");
+					put(grammarAccess.getInstanceCreationExpressionAccess().getConstructorAssignment_1(), "rule__InstanceCreationExpression__ConstructorAssignment_1");
+					put(grammarAccess.getInstanceCreationExpressionAccess().getTupleAssignment_2(), "rule__InstanceCreationExpression__TupleAssignment_2");
+					put(grammarAccess.getInstanceCreationExpressionAccess().getSuffixAssignment_3(), "rule__InstanceCreationExpression__SuffixAssignment_3");
+					put(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_0(), "rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0");
+					put(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_1_1(), "rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1");
+					put(grammarAccess.getInstanceCreationTupleElementAccess().getRoleAssignment_0(), "rule__InstanceCreationTupleElement__RoleAssignment_0");
+					put(grammarAccess.getInstanceCreationTupleElementAccess().getObjectAssignment_2(), "rule__InstanceCreationTupleElement__ObjectAssignment_2");
+					put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorAssignment_0_0(), "rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0");
+					put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAssignment_0_1_0(), "rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0");
+					put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionAssignment_0_1_1(), "rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1");
+					put(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionAssignment_1(), "rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1");
+					put(grammarAccess.getAccessCompletionAccess().getAccessIndexAssignment_0(), "rule__AccessCompletion__AccessIndexAssignment_0");
+					put(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionAssignment_1(), "rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1");
+					put(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_1(), "rule__SequenceConstructionExpression__SequenceElementAssignment_1");
+					put(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_2_0_1(), "rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1");
+					put(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperAssignment_2_1_1(), "rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1");
+					put(grammarAccess.getBlockAccess().getSequenceAssignment_2(), "rule__Block__SequenceAssignment_2");
+					put(grammarAccess.getStatementSequenceAccess().getStatementsAssignment(), "rule__StatementSequence__StatementsAssignment");
+					put(grammarAccess.getDocumentedStatementAccess().getCommentAssignment_0(), "rule__DocumentedStatement__CommentAssignment_0");
+					put(grammarAccess.getDocumentedStatementAccess().getStatementAssignment_1(), "rule__DocumentedStatement__StatementAssignment_1");
+					put(grammarAccess.getInlineStatementAccess().getLangageNameAssignment_3(), "rule__InlineStatement__LangageNameAssignment_3");
+					put(grammarAccess.getInlineStatementAccess().getBodyAssignment_5(), "rule__InlineStatement__BodyAssignment_5");
+					put(grammarAccess.getAnnotatedStatementAccess().getAnnotationAssignment_1(), "rule__AnnotatedStatement__AnnotationAssignment_1");
+					put(grammarAccess.getAnnotatedStatementAccess().getStatementAssignment_2(), "rule__AnnotatedStatement__StatementAssignment_2");
+					put(grammarAccess.getAnnotationAccess().getKindAssignment_0(), "rule__Annotation__KindAssignment_0");
+					put(grammarAccess.getAnnotationAccess().getArgsAssignment_1_1(), "rule__Annotation__ArgsAssignment_1_1");
+					put(grammarAccess.getAnnotationAccess().getArgsAssignment_1_2_1(), "rule__Annotation__ArgsAssignment_1_2_1");
+					put(grammarAccess.getBlockStatementAccess().getBlockAssignment(), "rule__BlockStatement__BlockAssignment");
+					put(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameAssignment_1(), "rule__LocalNameDeclarationStatement__VarNameAssignment_1");
+					put(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeAssignment_3(), "rule__LocalNameDeclarationStatement__TypeAssignment_3");
+					put(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorAssignment_4_0(), "rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0");
+					put(grammarAccess.getLocalNameDeclarationStatementAccess().getInitAssignment_6(), "rule__LocalNameDeclarationStatement__InitAssignment_6");
+					put(grammarAccess.getIfStatementAccess().getSequentialClaussesAssignment_1(), "rule__IfStatement__SequentialClaussesAssignment_1");
+					put(grammarAccess.getIfStatementAccess().getFinalClauseAssignment_2(), "rule__IfStatement__FinalClauseAssignment_2");
+					put(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_0(), "rule__SequentialClauses__ConccurentClausesAssignment_0");
+					put(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_1_2(), "rule__SequentialClauses__ConccurentClausesAssignment_1_2");
+					put(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_0(), "rule__ConcurrentClauses__NonFinalClauseAssignment_0");
+					put(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_1_2(), "rule__ConcurrentClauses__NonFinalClauseAssignment_1_2");
+					put(grammarAccess.getNonFinalClauseAccess().getConditionAssignment_1(), "rule__NonFinalClause__ConditionAssignment_1");
+					put(grammarAccess.getNonFinalClauseAccess().getBlockAssignment_3(), "rule__NonFinalClause__BlockAssignment_3");
+					put(grammarAccess.getFinalClauseAccess().getBlockAssignment_1(), "rule__FinalClause__BlockAssignment_1");
+					put(grammarAccess.getSwitchStatementAccess().getExpressionAssignment_2(), "rule__SwitchStatement__ExpressionAssignment_2");
+					put(grammarAccess.getSwitchStatementAccess().getSwitchClauseAssignment_5(), "rule__SwitchStatement__SwitchClauseAssignment_5");
+					put(grammarAccess.getSwitchStatementAccess().getDefaultClauseAssignment_6(), "rule__SwitchStatement__DefaultClauseAssignment_6");
+					put(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_0(), "rule__SwitchClause__SwitchCaseAssignment_0");
+					put(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_1(), "rule__SwitchClause__SwitchCaseAssignment_1");
+					put(grammarAccess.getSwitchClauseAccess().getStatementSequenceAssignment_2(), "rule__SwitchClause__StatementSequenceAssignment_2");
+					put(grammarAccess.getSwitchCaseAccess().getExpressionAssignment_1(), "rule__SwitchCase__ExpressionAssignment_1");
+					put(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceAssignment_2(), "rule__SwitchDefaultClause__StatementSequenceAssignment_2");
+					put(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment(), "rule__NonEmptyStatementSequence__StatementAssignment");
+					put(grammarAccess.getWhileStatementAccess().getConditionAssignment_2(), "rule__WhileStatement__ConditionAssignment_2");
+					put(grammarAccess.getWhileStatementAccess().getBlockAssignment_4(), "rule__WhileStatement__BlockAssignment_4");
+					put(grammarAccess.getDoStatementAccess().getBlockAssignment_1(), "rule__DoStatement__BlockAssignment_1");
+					put(grammarAccess.getDoStatementAccess().getConditionAssignment_4(), "rule__DoStatement__ConditionAssignment_4");
+					put(grammarAccess.getForStatementAccess().getControlAssignment_2(), "rule__ForStatement__ControlAssignment_2");
+					put(grammarAccess.getForStatementAccess().getBlockAssignment_4(), "rule__ForStatement__BlockAssignment_4");
+					put(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_0(), "rule__ForControl__LoopVariableDefinitionAssignment_0");
+					put(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_1_1(), "rule__ForControl__LoopVariableDefinitionAssignment_1_1");
+					put(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_0_0(), "rule__LoopVariableDefinition__NameAssignment_0_0");
+					put(grammarAccess.getLoopVariableDefinitionAccess().getExpression1Assignment_0_2(), "rule__LoopVariableDefinition__Expression1Assignment_0_2");
+					put(grammarAccess.getLoopVariableDefinitionAccess().getExpression2Assignment_0_3_1(), "rule__LoopVariableDefinition__Expression2Assignment_0_3_1");
+					put(grammarAccess.getLoopVariableDefinitionAccess().getTypeAssignment_1_0(), "rule__LoopVariableDefinition__TypeAssignment_1_0");
+					put(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_1_1(), "rule__LoopVariableDefinition__NameAssignment_1_1");
+					put(grammarAccess.getLoopVariableDefinitionAccess().getExpressionAssignment_1_3(), "rule__LoopVariableDefinition__ExpressionAssignment_1_3");
+					put(grammarAccess.getReturnStatementAccess().getExpressionAssignment_1(), "rule__ReturnStatement__ExpressionAssignment_1");
+					put(grammarAccess.getAcceptStatementAccess().getClauseAssignment_0(), "rule__AcceptStatement__ClauseAssignment_0");
+					put(grammarAccess.getAcceptStatementAccess().getSimpleAcceptAssignment_1_0(), "rule__AcceptStatement__SimpleAcceptAssignment_1_0");
+					put(grammarAccess.getAcceptStatementAccess().getCompoundAcceptAssignment_1_1(), "rule__AcceptStatement__CompoundAcceptAssignment_1_1");
+					put(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockAssignment_0(), "rule__CompoundAcceptStatementCompletion__BlockAssignment_0");
+					put(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAssignment_1_1(), "rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1");
+					put(grammarAccess.getAcceptBlockAccess().getClauseAssignment_0(), "rule__AcceptBlock__ClauseAssignment_0");
+					put(grammarAccess.getAcceptBlockAccess().getBlockAssignment_1(), "rule__AcceptBlock__BlockAssignment_1");
+					put(grammarAccess.getAcceptClauseAccess().getNameAssignment_2_0(), "rule__AcceptClause__NameAssignment_2_0");
+					put(grammarAccess.getAcceptClauseAccess().getQualifiedNameListAssignment_3(), "rule__AcceptClause__QualifiedNameListAssignment_3");
+					put(grammarAccess.getClassifyStatementAccess().getExpressionAssignment_1(), "rule__ClassifyStatement__ExpressionAssignment_1");
+					put(grammarAccess.getClassifyStatementAccess().getClauseAssignment_2(), "rule__ClassifyStatement__ClauseAssignment_2");
+					put(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseAssignment_0_0(), "rule__ClassificationClause__ClassifyFromClauseAssignment_0_0");
+					put(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_0_1(), "rule__ClassificationClause__ClassifyToClauseAssignment_0_1");
+					put(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseAssignment_1_0(), "rule__ClassificationClause__ReclassyAllClauseAssignment_1_0");
+					put(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_1_1(), "rule__ClassificationClause__ClassifyToClauseAssignment_1_1");
+					put(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListAssignment_1(), "rule__ClassificationFromClause__QualifiedNameListAssignment_1");
+					put(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListAssignment_1(), "rule__ClassificationToClause__QualifiedNameListAssignment_1");
+					put(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_0(), "rule__QualifiedNameList__QualifiedNameAssignment_0");
+					put(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_1_1(), "rule__QualifiedNameList__QualifiedNameAssignment_1_1");
+					put(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartAssignment_0(), "rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0");
+					put(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionAssignment_1_0(), "rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0");
+					put(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignment_1_1(), "rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1");
+					put(grammarAccess.getSuperInvocationStatementAccess().get_superAssignment_0(), "rule__SuperInvocationStatement___superAssignment_0");
+					put(grammarAccess.getThisInvocationStatementAccess().get_thisAssignment_0(), "rule__ThisInvocationStatement___thisAssignment_0");
+					put(grammarAccess.getThisInvocationStatementAccess().getAssignmentCompletionAssignment_1(), "rule__ThisInvocationStatement__AssignmentCompletionAssignment_1");
+					put(grammarAccess.getInstanceCreationInvocationStatementAccess().get_newAssignment_0(), "rule__InstanceCreationInvocationStatement___newAssignment_0");
+					put(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorAssignment_0_0(), "rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0");
+					put(grammarAccess.getVariableDeclarationCompletionAccess().getVariableNameAssignment_1(), "rule__VariableDeclarationCompletion__VariableNameAssignment_1");
+					put(grammarAccess.getVariableDeclarationCompletionAccess().getInitValueAssignment_2(), "rule__VariableDeclarationCompletion__InitValueAssignment_2");
+					put(grammarAccess.getAssignmentCompletionAccess().getOpAssignment_0(), "rule__AssignmentCompletion__OpAssignment_0");
+					put(grammarAccess.getAssignmentCompletionAccess().getRightHandSideAssignment_1(), "rule__AssignmentCompletion__RightHandSideAssignment_1");
+				}
+			};
+		}
+		return nameMappings.get(element);
+	}
+	
+	@Override
+	protected Collection<FollowElement> getFollowElements(AbstractInternalContentAssistParser parser) {
+		try {
+			org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfParser typedParser = (org.eclipse.papyrus.alf.ui.contentassist.antlr.internal.InternalAlfParser) parser;
+			typedParser.entryRuleTest();
+			return typedParser.getFollowElements();
+		} catch(RecognitionException ex) {
+			throw new RuntimeException(ex);
+		}		
+	}
+	
+	@Override
+	protected String[] getInitialHiddenTokens() {
+		return new String[] { "RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT" };
+	}
+	
+	public AlfGrammarAccess getGrammarAccess() {
+		return this.grammarAccess;
+	}
+	
+	public void setGrammarAccess(AlfGrammarAccess grammarAccess) {
+		this.grammarAccess = grammarAccess;
+	}
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g
new file mode 100644
index 00000000000..e04b09fc02a
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g
@@ -0,0 +1,19052 @@
+/*
+* generated by Xtext
+*/
+grammar InternalAlf;
+
+options {
+	superClass=AbstractInternalContentAssistParser;
+	
+}
+
+@lexer::header {
+package org.eclipse.papyrus.alf.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.papyrus.alf.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.papyrus.alf.services.AlfGrammarAccess;
+
+}
+
+@parser::members {
+ 
+ 	private AlfGrammarAccess grammarAccess;
+ 	
+    public void setGrammarAccess(AlfGrammarAccess grammarAccess) {
+    	this.grammarAccess = grammarAccess;
+    }
+    
+    @Override
+    protected Grammar getGrammar() {
+    	return grammarAccess.getGrammar();
+    }
+    
+    @Override
+    protected String getValueForTokenName(String tokenName) {
+    	return tokenName;
+    }
+
+}
+
+
+
+
+// Entry rule entryRuleTest
+entryRuleTest 
+:
+{ before(grammarAccess.getTestRule()); }
+	 ruleTest
+{ after(grammarAccess.getTestRule()); } 
+	 EOF 
+;
+
+// Rule Test
+ruleTest
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTestAccess().getGroup()); }
+(rule__Test__Group__0)
+{ after(grammarAccess.getTestAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLITERAL
+entryRuleLITERAL 
+:
+{ before(grammarAccess.getLITERALRule()); }
+	 ruleLITERAL
+{ after(grammarAccess.getLITERALRule()); } 
+	 EOF 
+;
+
+// Rule LITERAL
+ruleLITERAL
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getLITERALAccess().getAlternatives()); }
+(rule__LITERAL__Alternatives)
+{ after(grammarAccess.getLITERALAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleBOOLEAN_LITERAL
+entryRuleBOOLEAN_LITERAL 
+:
+{ before(grammarAccess.getBOOLEAN_LITERALRule()); }
+	 ruleBOOLEAN_LITERAL
+{ after(grammarAccess.getBOOLEAN_LITERALRule()); } 
+	 EOF 
+;
+
+// Rule BOOLEAN_LITERAL
+ruleBOOLEAN_LITERAL
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getBOOLEAN_LITERALAccess().getValueAssignment()); }
+(rule__BOOLEAN_LITERAL__ValueAssignment)
+{ after(grammarAccess.getBOOLEAN_LITERALAccess().getValueAssignment()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNUMBER_LITERAL
+entryRuleNUMBER_LITERAL 
+:
+{ before(grammarAccess.getNUMBER_LITERALRule()); }
+	 ruleNUMBER_LITERAL
+{ after(grammarAccess.getNUMBER_LITERALRule()); } 
+	 EOF 
+;
+
+// Rule NUMBER_LITERAL
+ruleNUMBER_LITERAL
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getNUMBER_LITERALAccess().getAlternatives()); }
+(rule__NUMBER_LITERAL__Alternatives)
+{ after(grammarAccess.getNUMBER_LITERALAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleINTEGER_LITERAL
+entryRuleINTEGER_LITERAL 
+:
+{ before(grammarAccess.getINTEGER_LITERALRule()); }
+	 ruleINTEGER_LITERAL
+{ after(grammarAccess.getINTEGER_LITERALRule()); } 
+	 EOF 
+;
+
+// Rule INTEGER_LITERAL
+ruleINTEGER_LITERAL
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getINTEGER_LITERALAccess().getValueAssignment()); }
+(rule__INTEGER_LITERAL__ValueAssignment)
+{ after(grammarAccess.getINTEGER_LITERALAccess().getValueAssignment()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleUNLIMITED_LITERAL
+entryRuleUNLIMITED_LITERAL 
+:
+{ before(grammarAccess.getUNLIMITED_LITERALRule()); }
+	 ruleUNLIMITED_LITERAL
+{ after(grammarAccess.getUNLIMITED_LITERALRule()); } 
+	 EOF 
+;
+
+// Rule UNLIMITED_LITERAL
+ruleUNLIMITED_LITERAL
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getUNLIMITED_LITERALAccess().getValueAssignment()); }
+(rule__UNLIMITED_LITERAL__ValueAssignment)
+{ after(grammarAccess.getUNLIMITED_LITERALAccess().getValueAssignment()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSTRING_LITERAL
+entryRuleSTRING_LITERAL 
+:
+{ before(grammarAccess.getSTRING_LITERALRule()); }
+	 ruleSTRING_LITERAL
+{ after(grammarAccess.getSTRING_LITERALRule()); } 
+	 EOF 
+;
+
+// Rule STRING_LITERAL
+ruleSTRING_LITERAL
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSTRING_LITERALAccess().getValueAssignment()); }
+(rule__STRING_LITERAL__ValueAssignment)
+{ after(grammarAccess.getSTRING_LITERALAccess().getValueAssignment()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNameExpression
+entryRuleNameExpression 
+:
+{ before(grammarAccess.getNameExpressionRule()); }
+	 ruleNameExpression
+{ after(grammarAccess.getNameExpressionRule()); } 
+	 EOF 
+;
+
+// Rule NameExpression
+ruleNameExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getNameExpressionAccess().getGroup()); }
+(rule__NameExpression__Group__0)
+{ after(grammarAccess.getNameExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleQualifiedNamePath
+entryRuleQualifiedNamePath 
+:
+{ before(grammarAccess.getQualifiedNamePathRule()); }
+	 ruleQualifiedNamePath
+{ after(grammarAccess.getQualifiedNamePathRule()); } 
+	 EOF 
+;
+
+// Rule QualifiedNamePath
+ruleQualifiedNamePath
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+(
+{ before(grammarAccess.getQualifiedNamePathAccess().getGroup()); }
+(rule__QualifiedNamePath__Group__0)
+{ after(grammarAccess.getQualifiedNamePathAccess().getGroup()); }
+)
+(
+{ before(grammarAccess.getQualifiedNamePathAccess().getGroup()); }
+(rule__QualifiedNamePath__Group__0)*
+{ after(grammarAccess.getQualifiedNamePathAccess().getGroup()); }
+)
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleUnqualifiedName
+entryRuleUnqualifiedName 
+:
+{ before(grammarAccess.getUnqualifiedNameRule()); }
+	 ruleUnqualifiedName
+{ after(grammarAccess.getUnqualifiedNameRule()); } 
+	 EOF 
+;
+
+// Rule UnqualifiedName
+ruleUnqualifiedName
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getUnqualifiedNameAccess().getGroup()); }
+(rule__UnqualifiedName__Group__0)
+{ after(grammarAccess.getUnqualifiedNameAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTemplateBinding
+entryRuleTemplateBinding 
+:
+{ before(grammarAccess.getTemplateBindingRule()); }
+	 ruleTemplateBinding
+{ after(grammarAccess.getTemplateBindingRule()); } 
+	 EOF 
+;
+
+// Rule TemplateBinding
+ruleTemplateBinding
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getGroup()); }
+(rule__TemplateBinding__Group__0)
+{ after(grammarAccess.getTemplateBindingAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNamedTemplateBinding
+entryRuleNamedTemplateBinding 
+:
+{ before(grammarAccess.getNamedTemplateBindingRule()); }
+	 ruleNamedTemplateBinding
+{ after(grammarAccess.getNamedTemplateBindingRule()); } 
+	 EOF 
+;
+
+// Rule NamedTemplateBinding
+ruleNamedTemplateBinding
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getNamedTemplateBindingAccess().getGroup()); }
+(rule__NamedTemplateBinding__Group__0)
+{ after(grammarAccess.getNamedTemplateBindingAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleQualifiedNameWithBinding
+entryRuleQualifiedNameWithBinding 
+:
+{ before(grammarAccess.getQualifiedNameWithBindingRule()); }
+	 ruleQualifiedNameWithBinding
+{ after(grammarAccess.getQualifiedNameWithBindingRule()); } 
+	 EOF 
+;
+
+// Rule QualifiedNameWithBinding
+ruleQualifiedNameWithBinding
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getGroup()); }
+(rule__QualifiedNameWithBinding__Group__0)
+{ after(grammarAccess.getQualifiedNameWithBindingAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTuple
+entryRuleTuple 
+:
+{ before(grammarAccess.getTupleRule()); }
+	 ruleTuple
+{ after(grammarAccess.getTupleRule()); } 
+	 EOF 
+;
+
+// Rule Tuple
+ruleTuple
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTupleAccess().getGroup()); }
+(rule__Tuple__Group__0)
+{ after(grammarAccess.getTupleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTupleElement
+entryRuleTupleElement 
+:
+{ before(grammarAccess.getTupleElementRule()); }
+	 ruleTupleElement
+{ after(grammarAccess.getTupleElementRule()); } 
+	 EOF 
+;
+
+// Rule TupleElement
+ruleTupleElement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTupleElementAccess().getArgumentAssignment()); }
+(rule__TupleElement__ArgumentAssignment)
+{ after(grammarAccess.getTupleElementAccess().getArgumentAssignment()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleExpression
+entryRuleExpression 
+:
+{ before(grammarAccess.getExpressionRule()); }
+	 ruleExpression
+{ after(grammarAccess.getExpressionRule()); } 
+	 EOF 
+;
+
+// Rule Expression
+ruleExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getExpressionAccess().getConditionalTestExpressionParserRuleCall()); }
+	ruleConditionalTestExpression
+{ after(grammarAccess.getExpressionAccess().getConditionalTestExpressionParserRuleCall()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleConditionalTestExpression
+entryRuleConditionalTestExpression 
+:
+{ before(grammarAccess.getConditionalTestExpressionRule()); }
+	 ruleConditionalTestExpression
+{ after(grammarAccess.getConditionalTestExpressionRule()); } 
+	 EOF 
+;
+
+// Rule ConditionalTestExpression
+ruleConditionalTestExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getGroup()); }
+(rule__ConditionalTestExpression__Group__0)
+{ after(grammarAccess.getConditionalTestExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleConditionalOrExpression
+entryRuleConditionalOrExpression 
+:
+{ before(grammarAccess.getConditionalOrExpressionRule()); }
+	 ruleConditionalOrExpression
+{ after(grammarAccess.getConditionalOrExpressionRule()); } 
+	 EOF 
+;
+
+// Rule ConditionalOrExpression
+ruleConditionalOrExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getGroup()); }
+(rule__ConditionalOrExpression__Group__0)
+{ after(grammarAccess.getConditionalOrExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleConditionalAndExpression
+entryRuleConditionalAndExpression 
+:
+{ before(grammarAccess.getConditionalAndExpressionRule()); }
+	 ruleConditionalAndExpression
+{ after(grammarAccess.getConditionalAndExpressionRule()); } 
+	 EOF 
+;
+
+// Rule ConditionalAndExpression
+ruleConditionalAndExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getGroup()); }
+(rule__ConditionalAndExpression__Group__0)
+{ after(grammarAccess.getConditionalAndExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInclusiveOrExpression
+entryRuleInclusiveOrExpression 
+:
+{ before(grammarAccess.getInclusiveOrExpressionRule()); }
+	 ruleInclusiveOrExpression
+{ after(grammarAccess.getInclusiveOrExpressionRule()); } 
+	 EOF 
+;
+
+// Rule InclusiveOrExpression
+ruleInclusiveOrExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getGroup()); }
+(rule__InclusiveOrExpression__Group__0)
+{ after(grammarAccess.getInclusiveOrExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleExclusiveOrExpression
+entryRuleExclusiveOrExpression 
+:
+{ before(grammarAccess.getExclusiveOrExpressionRule()); }
+	 ruleExclusiveOrExpression
+{ after(grammarAccess.getExclusiveOrExpressionRule()); } 
+	 EOF 
+;
+
+// Rule ExclusiveOrExpression
+ruleExclusiveOrExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getGroup()); }
+(rule__ExclusiveOrExpression__Group__0)
+{ after(grammarAccess.getExclusiveOrExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAndExpression
+entryRuleAndExpression 
+:
+{ before(grammarAccess.getAndExpressionRule()); }
+	 ruleAndExpression
+{ after(grammarAccess.getAndExpressionRule()); } 
+	 EOF 
+;
+
+// Rule AndExpression
+ruleAndExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getAndExpressionAccess().getGroup()); }
+(rule__AndExpression__Group__0)
+{ after(grammarAccess.getAndExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleEqualityExpression
+entryRuleEqualityExpression 
+:
+{ before(grammarAccess.getEqualityExpressionRule()); }
+	 ruleEqualityExpression
+{ after(grammarAccess.getEqualityExpressionRule()); } 
+	 EOF 
+;
+
+// Rule EqualityExpression
+ruleEqualityExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getGroup()); }
+(rule__EqualityExpression__Group__0)
+{ after(grammarAccess.getEqualityExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleClassificationExpression
+entryRuleClassificationExpression 
+:
+{ before(grammarAccess.getClassificationExpressionRule()); }
+	 ruleClassificationExpression
+{ after(grammarAccess.getClassificationExpressionRule()); } 
+	 EOF 
+;
+
+// Rule ClassificationExpression
+ruleClassificationExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getGroup()); }
+(rule__ClassificationExpression__Group__0)
+{ after(grammarAccess.getClassificationExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleRelationalExpression
+entryRuleRelationalExpression 
+:
+{ before(grammarAccess.getRelationalExpressionRule()); }
+	 ruleRelationalExpression
+{ after(grammarAccess.getRelationalExpressionRule()); } 
+	 EOF 
+;
+
+// Rule RelationalExpression
+ruleRelationalExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getGroup()); }
+(rule__RelationalExpression__Group__0)
+{ after(grammarAccess.getRelationalExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleShiftExpression
+entryRuleShiftExpression 
+:
+{ before(grammarAccess.getShiftExpressionRule()); }
+	 ruleShiftExpression
+{ after(grammarAccess.getShiftExpressionRule()); } 
+	 EOF 
+;
+
+// Rule ShiftExpression
+ruleShiftExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getGroup()); }
+(rule__ShiftExpression__Group__0)
+{ after(grammarAccess.getShiftExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAdditiveExpression
+entryRuleAdditiveExpression 
+:
+{ before(grammarAccess.getAdditiveExpressionRule()); }
+	 ruleAdditiveExpression
+{ after(grammarAccess.getAdditiveExpressionRule()); } 
+	 EOF 
+;
+
+// Rule AdditiveExpression
+ruleAdditiveExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getGroup()); }
+(rule__AdditiveExpression__Group__0)
+{ after(grammarAccess.getAdditiveExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleMultiplicativeExpression
+entryRuleMultiplicativeExpression 
+:
+{ before(grammarAccess.getMultiplicativeExpressionRule()); }
+	 ruleMultiplicativeExpression
+{ after(grammarAccess.getMultiplicativeExpressionRule()); } 
+	 EOF 
+;
+
+// Rule MultiplicativeExpression
+ruleMultiplicativeExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); }
+(rule__MultiplicativeExpression__Group__0)
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleUnaryExpression
+entryRuleUnaryExpression 
+:
+{ before(grammarAccess.getUnaryExpressionRule()); }
+	 ruleUnaryExpression
+{ after(grammarAccess.getUnaryExpressionRule()); } 
+	 EOF 
+;
+
+// Rule UnaryExpression
+ruleUnaryExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getUnaryExpressionAccess().getGroup()); }
+(rule__UnaryExpression__Group__0)
+{ after(grammarAccess.getUnaryExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePrimaryExpression
+entryRulePrimaryExpression 
+:
+{ before(grammarAccess.getPrimaryExpressionRule()); }
+	 rulePrimaryExpression
+{ after(grammarAccess.getPrimaryExpressionRule()); } 
+	 EOF 
+;
+
+// Rule PrimaryExpression
+rulePrimaryExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getPrefixAssignment()); }
+(rule__PrimaryExpression__PrefixAssignment)
+{ after(grammarAccess.getPrimaryExpressionAccess().getPrefixAssignment()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSuffixExpression
+entryRuleSuffixExpression 
+:
+{ before(grammarAccess.getSuffixExpressionRule()); }
+	 ruleSuffixExpression
+{ after(grammarAccess.getSuffixExpressionRule()); } 
+	 EOF 
+;
+
+// Rule SuffixExpression
+ruleSuffixExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSuffixExpressionAccess().getAlternatives()); }
+(rule__SuffixExpression__Alternatives)
+{ after(grammarAccess.getSuffixExpressionAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleOperationCallExpression
+entryRuleOperationCallExpression 
+:
+{ before(grammarAccess.getOperationCallExpressionRule()); }
+	 ruleOperationCallExpression
+{ after(grammarAccess.getOperationCallExpressionRule()); } 
+	 EOF 
+;
+
+// Rule OperationCallExpression
+ruleOperationCallExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getGroup()); }
+(rule__OperationCallExpression__Group__0)
+{ after(grammarAccess.getOperationCallExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyCallExpression
+entryRulePropertyCallExpression 
+:
+{ before(grammarAccess.getPropertyCallExpressionRule()); }
+	 rulePropertyCallExpression
+{ after(grammarAccess.getPropertyCallExpressionRule()); } 
+	 EOF 
+;
+
+// Rule PropertyCallExpression
+rulePropertyCallExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getGroup()); }
+(rule__PropertyCallExpression__Group__0)
+{ after(grammarAccess.getPropertyCallExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLinkOperationExpression
+entryRuleLinkOperationExpression 
+:
+{ before(grammarAccess.getLinkOperationExpressionRule()); }
+	 ruleLinkOperationExpression
+{ after(grammarAccess.getLinkOperationExpressionRule()); } 
+	 EOF 
+;
+
+// Rule LinkOperationExpression
+ruleLinkOperationExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getLinkOperationExpressionAccess().getGroup()); }
+(rule__LinkOperationExpression__Group__0)
+{ after(grammarAccess.getLinkOperationExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLinkOperationTuple
+entryRuleLinkOperationTuple 
+:
+{ before(grammarAccess.getLinkOperationTupleRule()); }
+	 ruleLinkOperationTuple
+{ after(grammarAccess.getLinkOperationTupleRule()); } 
+	 EOF 
+;
+
+// Rule LinkOperationTuple
+ruleLinkOperationTuple
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getGroup()); }
+(rule__LinkOperationTuple__Group__0)
+{ after(grammarAccess.getLinkOperationTupleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLinkOperationTupleElement
+entryRuleLinkOperationTupleElement 
+:
+{ before(grammarAccess.getLinkOperationTupleElementRule()); }
+	 ruleLinkOperationTupleElement
+{ after(grammarAccess.getLinkOperationTupleElementRule()); } 
+	 EOF 
+;
+
+// Rule LinkOperationTupleElement
+ruleLinkOperationTupleElement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getGroup()); }
+(rule__LinkOperationTupleElement__Group__0)
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequenceOperationExpression
+entryRuleSequenceOperationExpression 
+:
+{ before(grammarAccess.getSequenceOperationExpressionRule()); }
+	 ruleSequenceOperationExpression
+{ after(grammarAccess.getSequenceOperationExpressionRule()); } 
+	 EOF 
+;
+
+// Rule SequenceOperationExpression
+ruleSequenceOperationExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getGroup()); }
+(rule__SequenceOperationExpression__Group__0)
+{ after(grammarAccess.getSequenceOperationExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequenceReductionExpression
+entryRuleSequenceReductionExpression 
+:
+{ before(grammarAccess.getSequenceReductionExpressionRule()); }
+	 ruleSequenceReductionExpression
+{ after(grammarAccess.getSequenceReductionExpressionRule()); } 
+	 EOF 
+;
+
+// Rule SequenceReductionExpression
+ruleSequenceReductionExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getGroup()); }
+(rule__SequenceReductionExpression__Group__0)
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequenceExpansionExpression
+entryRuleSequenceExpansionExpression 
+:
+{ before(grammarAccess.getSequenceExpansionExpressionRule()); }
+	 ruleSequenceExpansionExpression
+{ after(grammarAccess.getSequenceExpansionExpressionRule()); } 
+	 EOF 
+;
+
+// Rule SequenceExpansionExpression
+ruleSequenceExpansionExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSequenceExpansionExpressionAccess().getAlternatives()); }
+(rule__SequenceExpansionExpression__Alternatives)
+{ after(grammarAccess.getSequenceExpansionExpressionAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSelectOrRejectOperation
+entryRuleSelectOrRejectOperation 
+:
+{ before(grammarAccess.getSelectOrRejectOperationRule()); }
+	 ruleSelectOrRejectOperation
+{ after(grammarAccess.getSelectOrRejectOperationRule()); } 
+	 EOF 
+;
+
+// Rule SelectOrRejectOperation
+ruleSelectOrRejectOperation
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getGroup()); }
+(rule__SelectOrRejectOperation__Group__0)
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleCollectOrIterateOperation
+entryRuleCollectOrIterateOperation 
+:
+{ before(grammarAccess.getCollectOrIterateOperationRule()); }
+	 ruleCollectOrIterateOperation
+{ after(grammarAccess.getCollectOrIterateOperationRule()); } 
+	 EOF 
+;
+
+// Rule CollectOrIterateOperation
+ruleCollectOrIterateOperation
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getGroup()); }
+(rule__CollectOrIterateOperation__Group__0)
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleForAllOrExistsOrOneOperation
+entryRuleForAllOrExistsOrOneOperation 
+:
+{ before(grammarAccess.getForAllOrExistsOrOneOperationRule()); }
+	 ruleForAllOrExistsOrOneOperation
+{ after(grammarAccess.getForAllOrExistsOrOneOperationRule()); } 
+	 EOF 
+;
+
+// Rule ForAllOrExistsOrOneOperation
+ruleForAllOrExistsOrOneOperation
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getGroup()); }
+(rule__ForAllOrExistsOrOneOperation__Group__0)
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleIsUniqueOperation
+entryRuleIsUniqueOperation 
+:
+{ before(grammarAccess.getIsUniqueOperationRule()); }
+	 ruleIsUniqueOperation
+{ after(grammarAccess.getIsUniqueOperationRule()); } 
+	 EOF 
+;
+
+// Rule IsUniqueOperation
+ruleIsUniqueOperation
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getGroup()); }
+(rule__IsUniqueOperation__Group__0)
+{ after(grammarAccess.getIsUniqueOperationAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleValueSpecification
+entryRuleValueSpecification 
+:
+{ before(grammarAccess.getValueSpecificationRule()); }
+	 ruleValueSpecification
+{ after(grammarAccess.getValueSpecificationRule()); } 
+	 EOF 
+;
+
+// Rule ValueSpecification
+ruleValueSpecification
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getValueSpecificationAccess().getAlternatives()); }
+(rule__ValueSpecification__Alternatives)
+{ after(grammarAccess.getValueSpecificationAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNonLiteralValueSpecification
+entryRuleNonLiteralValueSpecification 
+:
+{ before(grammarAccess.getNonLiteralValueSpecificationRule()); }
+	 ruleNonLiteralValueSpecification
+{ after(grammarAccess.getNonLiteralValueSpecificationRule()); } 
+	 EOF 
+;
+
+// Rule NonLiteralValueSpecification
+ruleNonLiteralValueSpecification
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getNonLiteralValueSpecificationAccess().getAlternatives()); }
+(rule__NonLiteralValueSpecification__Alternatives)
+{ after(grammarAccess.getNonLiteralValueSpecificationAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleParenthesizedExpression
+entryRuleParenthesizedExpression 
+:
+{ before(grammarAccess.getParenthesizedExpressionRule()); }
+	 ruleParenthesizedExpression
+{ after(grammarAccess.getParenthesizedExpressionRule()); } 
+	 EOF 
+;
+
+// Rule ParenthesizedExpression
+ruleParenthesizedExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getGroup()); }
+(rule__ParenthesizedExpression__Group__0)
+{ after(grammarAccess.getParenthesizedExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNullExpression
+entryRuleNullExpression 
+:
+{ before(grammarAccess.getNullExpressionRule()); }
+	 ruleNullExpression
+{ after(grammarAccess.getNullExpressionRule()); } 
+	 EOF 
+;
+
+// Rule NullExpression
+ruleNullExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getNullExpressionAccess().getGroup()); }
+(rule__NullExpression__Group__0)
+{ after(grammarAccess.getNullExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleThisExpression
+entryRuleThisExpression 
+:
+{ before(grammarAccess.getThisExpressionRule()); }
+	 ruleThisExpression
+{ after(grammarAccess.getThisExpressionRule()); } 
+	 EOF 
+;
+
+// Rule ThisExpression
+ruleThisExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getThisExpressionAccess().getGroup()); }
+(rule__ThisExpression__Group__0)
+{ after(grammarAccess.getThisExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSuperInvocationExpression
+entryRuleSuperInvocationExpression 
+:
+{ before(grammarAccess.getSuperInvocationExpressionRule()); }
+	 ruleSuperInvocationExpression
+{ after(grammarAccess.getSuperInvocationExpressionRule()); } 
+	 EOF 
+;
+
+// Rule SuperInvocationExpression
+ruleSuperInvocationExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getGroup()); }
+(rule__SuperInvocationExpression__Group__0)
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInstanceCreationExpression
+entryRuleInstanceCreationExpression 
+:
+{ before(grammarAccess.getInstanceCreationExpressionRule()); }
+	 ruleInstanceCreationExpression
+{ after(grammarAccess.getInstanceCreationExpressionRule()); } 
+	 EOF 
+;
+
+// Rule InstanceCreationExpression
+ruleInstanceCreationExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getGroup()); }
+(rule__InstanceCreationExpression__Group__0)
+{ after(grammarAccess.getInstanceCreationExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInstanceCreationTuple
+entryRuleInstanceCreationTuple 
+:
+{ before(grammarAccess.getInstanceCreationTupleRule()); }
+	 ruleInstanceCreationTuple
+{ after(grammarAccess.getInstanceCreationTupleRule()); } 
+	 EOF 
+;
+
+// Rule InstanceCreationTuple
+ruleInstanceCreationTuple
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getGroup()); }
+(rule__InstanceCreationTuple__Group__0)
+{ after(grammarAccess.getInstanceCreationTupleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInstanceCreationTupleElement
+entryRuleInstanceCreationTupleElement 
+:
+{ before(grammarAccess.getInstanceCreationTupleElementRule()); }
+	 ruleInstanceCreationTupleElement
+{ after(grammarAccess.getInstanceCreationTupleElementRule()); } 
+	 EOF 
+;
+
+// Rule InstanceCreationTupleElement
+ruleInstanceCreationTupleElement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getInstanceCreationTupleElementAccess().getGroup()); }
+(rule__InstanceCreationTupleElement__Group__0)
+{ after(grammarAccess.getInstanceCreationTupleElementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequenceConstructionOrAccessCompletion
+entryRuleSequenceConstructionOrAccessCompletion 
+:
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionRule()); }
+	 ruleSequenceConstructionOrAccessCompletion
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionRule()); } 
+	 EOF 
+;
+
+// Rule SequenceConstructionOrAccessCompletion
+ruleSequenceConstructionOrAccessCompletion
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives()); }
+(rule__SequenceConstructionOrAccessCompletion__Alternatives)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAccessCompletion
+entryRuleAccessCompletion 
+:
+{ before(grammarAccess.getAccessCompletionRule()); }
+	 ruleAccessCompletion
+{ after(grammarAccess.getAccessCompletionRule()); } 
+	 EOF 
+;
+
+// Rule AccessCompletion
+ruleAccessCompletion
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getAccessCompletionAccess().getGroup()); }
+(rule__AccessCompletion__Group__0)
+{ after(grammarAccess.getAccessCompletionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePartialSequenceConstructionCompletion
+entryRulePartialSequenceConstructionCompletion 
+:
+{ before(grammarAccess.getPartialSequenceConstructionCompletionRule()); }
+	 rulePartialSequenceConstructionCompletion
+{ after(grammarAccess.getPartialSequenceConstructionCompletionRule()); } 
+	 EOF 
+;
+
+// Rule PartialSequenceConstructionCompletion
+rulePartialSequenceConstructionCompletion
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPartialSequenceConstructionCompletionAccess().getGroup()); }
+(rule__PartialSequenceConstructionCompletion__Group__0)
+{ after(grammarAccess.getPartialSequenceConstructionCompletionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequenceConstructionExpression
+entryRuleSequenceConstructionExpression 
+:
+{ before(grammarAccess.getSequenceConstructionExpressionRule()); }
+	 ruleSequenceConstructionExpression
+{ after(grammarAccess.getSequenceConstructionExpressionRule()); } 
+	 EOF 
+;
+
+// Rule SequenceConstructionExpression
+ruleSequenceConstructionExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getGroup()); }
+(rule__SequenceConstructionExpression__Group__0)
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequenceElement
+entryRuleSequenceElement 
+:
+{ before(grammarAccess.getSequenceElementRule()); }
+	 ruleSequenceElement
+{ after(grammarAccess.getSequenceElementRule()); } 
+	 EOF 
+;
+
+// Rule SequenceElement
+ruleSequenceElement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSequenceElementAccess().getAlternatives()); }
+(rule__SequenceElement__Alternatives)
+{ after(grammarAccess.getSequenceElementAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleClassExtentExpression
+entryRuleClassExtentExpression 
+:
+{ before(grammarAccess.getClassExtentExpressionRule()); }
+	 ruleClassExtentExpression
+{ after(grammarAccess.getClassExtentExpressionRule()); } 
+	 EOF 
+;
+
+// Rule ClassExtentExpression
+ruleClassExtentExpression
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getClassExtentExpressionAccess().getGroup()); }
+(rule__ClassExtentExpression__Group__0)
+{ after(grammarAccess.getClassExtentExpressionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleBlock
+entryRuleBlock 
+:
+{ before(grammarAccess.getBlockRule()); }
+	 ruleBlock
+{ after(grammarAccess.getBlockRule()); } 
+	 EOF 
+;
+
+// Rule Block
+ruleBlock
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getBlockAccess().getGroup()); }
+(rule__Block__Group__0)
+{ after(grammarAccess.getBlockAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleStatementSequence
+entryRuleStatementSequence 
+:
+{ before(grammarAccess.getStatementSequenceRule()); }
+	 ruleStatementSequence
+{ after(grammarAccess.getStatementSequenceRule()); } 
+	 EOF 
+;
+
+// Rule StatementSequence
+ruleStatementSequence
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+(
+{ before(grammarAccess.getStatementSequenceAccess().getStatementsAssignment()); }
+(rule__StatementSequence__StatementsAssignment)
+{ after(grammarAccess.getStatementSequenceAccess().getStatementsAssignment()); }
+)
+(
+{ before(grammarAccess.getStatementSequenceAccess().getStatementsAssignment()); }
+(rule__StatementSequence__StatementsAssignment)*
+{ after(grammarAccess.getStatementSequenceAccess().getStatementsAssignment()); }
+)
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleDocumentedStatement
+entryRuleDocumentedStatement 
+:
+{ before(grammarAccess.getDocumentedStatementRule()); }
+	 ruleDocumentedStatement
+{ after(grammarAccess.getDocumentedStatementRule()); } 
+	 EOF 
+;
+
+// Rule DocumentedStatement
+ruleDocumentedStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getDocumentedStatementAccess().getGroup()); }
+(rule__DocumentedStatement__Group__0)
+{ after(grammarAccess.getDocumentedStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInlineStatement
+entryRuleInlineStatement 
+:
+{ before(grammarAccess.getInlineStatementRule()); }
+	 ruleInlineStatement
+{ after(grammarAccess.getInlineStatementRule()); } 
+	 EOF 
+;
+
+// Rule InlineStatement
+ruleInlineStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getInlineStatementAccess().getGroup()); }
+(rule__InlineStatement__Group__0)
+{ after(grammarAccess.getInlineStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAnnotatedStatement
+entryRuleAnnotatedStatement 
+:
+{ before(grammarAccess.getAnnotatedStatementRule()); }
+	 ruleAnnotatedStatement
+{ after(grammarAccess.getAnnotatedStatementRule()); } 
+	 EOF 
+;
+
+// Rule AnnotatedStatement
+ruleAnnotatedStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getAnnotatedStatementAccess().getGroup()); }
+(rule__AnnotatedStatement__Group__0)
+{ after(grammarAccess.getAnnotatedStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleStatement
+entryRuleStatement 
+:
+{ before(grammarAccess.getStatementRule()); }
+	 ruleStatement
+{ after(grammarAccess.getStatementRule()); } 
+	 EOF 
+;
+
+// Rule Statement
+ruleStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getStatementAccess().getAlternatives()); }
+(rule__Statement__Alternatives)
+{ after(grammarAccess.getStatementAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAnnotation
+entryRuleAnnotation 
+:
+{ before(grammarAccess.getAnnotationRule()); }
+	 ruleAnnotation
+{ after(grammarAccess.getAnnotationRule()); } 
+	 EOF 
+;
+
+// Rule Annotation
+ruleAnnotation
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getAnnotationAccess().getGroup()); }
+(rule__Annotation__Group__0)
+{ after(grammarAccess.getAnnotationAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleBlockStatement
+entryRuleBlockStatement 
+:
+{ before(grammarAccess.getBlockStatementRule()); }
+	 ruleBlockStatement
+{ after(grammarAccess.getBlockStatementRule()); } 
+	 EOF 
+;
+
+// Rule BlockStatement
+ruleBlockStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getBlockStatementAccess().getBlockAssignment()); }
+(rule__BlockStatement__BlockAssignment)
+{ after(grammarAccess.getBlockStatementAccess().getBlockAssignment()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleEmptyStatement
+entryRuleEmptyStatement 
+:
+{ before(grammarAccess.getEmptyStatementRule()); }
+	 ruleEmptyStatement
+{ after(grammarAccess.getEmptyStatementRule()); } 
+	 EOF 
+;
+
+// Rule EmptyStatement
+ruleEmptyStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getEmptyStatementAccess().getGroup()); }
+(rule__EmptyStatement__Group__0)
+{ after(grammarAccess.getEmptyStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLocalNameDeclarationStatement
+entryRuleLocalNameDeclarationStatement 
+:
+{ before(grammarAccess.getLocalNameDeclarationStatementRule()); }
+	 ruleLocalNameDeclarationStatement
+{ after(grammarAccess.getLocalNameDeclarationStatementRule()); } 
+	 EOF 
+;
+
+// Rule LocalNameDeclarationStatement
+ruleLocalNameDeclarationStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup()); }
+(rule__LocalNameDeclarationStatement__Group__0)
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleIfStatement
+entryRuleIfStatement 
+:
+{ before(grammarAccess.getIfStatementRule()); }
+	 ruleIfStatement
+{ after(grammarAccess.getIfStatementRule()); } 
+	 EOF 
+;
+
+// Rule IfStatement
+ruleIfStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getIfStatementAccess().getGroup()); }
+(rule__IfStatement__Group__0)
+{ after(grammarAccess.getIfStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSequentialClauses
+entryRuleSequentialClauses 
+:
+{ before(grammarAccess.getSequentialClausesRule()); }
+	 ruleSequentialClauses
+{ after(grammarAccess.getSequentialClausesRule()); } 
+	 EOF 
+;
+
+// Rule SequentialClauses
+ruleSequentialClauses
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getGroup()); }
+(rule__SequentialClauses__Group__0)
+{ after(grammarAccess.getSequentialClausesAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleConcurrentClauses
+entryRuleConcurrentClauses 
+:
+{ before(grammarAccess.getConcurrentClausesRule()); }
+	 ruleConcurrentClauses
+{ after(grammarAccess.getConcurrentClausesRule()); } 
+	 EOF 
+;
+
+// Rule ConcurrentClauses
+ruleConcurrentClauses
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getGroup()); }
+(rule__ConcurrentClauses__Group__0)
+{ after(grammarAccess.getConcurrentClausesAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNonFinalClause
+entryRuleNonFinalClause 
+:
+{ before(grammarAccess.getNonFinalClauseRule()); }
+	 ruleNonFinalClause
+{ after(grammarAccess.getNonFinalClauseRule()); } 
+	 EOF 
+;
+
+// Rule NonFinalClause
+ruleNonFinalClause
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getGroup()); }
+(rule__NonFinalClause__Group__0)
+{ after(grammarAccess.getNonFinalClauseAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleFinalClause
+entryRuleFinalClause 
+:
+{ before(grammarAccess.getFinalClauseRule()); }
+	 ruleFinalClause
+{ after(grammarAccess.getFinalClauseRule()); } 
+	 EOF 
+;
+
+// Rule FinalClause
+ruleFinalClause
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getFinalClauseAccess().getGroup()); }
+(rule__FinalClause__Group__0)
+{ after(grammarAccess.getFinalClauseAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSwitchStatement
+entryRuleSwitchStatement 
+:
+{ before(grammarAccess.getSwitchStatementRule()); }
+	 ruleSwitchStatement
+{ after(grammarAccess.getSwitchStatementRule()); } 
+	 EOF 
+;
+
+// Rule SwitchStatement
+ruleSwitchStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getGroup()); }
+(rule__SwitchStatement__Group__0)
+{ after(grammarAccess.getSwitchStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSwitchClause
+entryRuleSwitchClause 
+:
+{ before(grammarAccess.getSwitchClauseRule()); }
+	 ruleSwitchClause
+{ after(grammarAccess.getSwitchClauseRule()); } 
+	 EOF 
+;
+
+// Rule SwitchClause
+ruleSwitchClause
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSwitchClauseAccess().getGroup()); }
+(rule__SwitchClause__Group__0)
+{ after(grammarAccess.getSwitchClauseAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSwitchCase
+entryRuleSwitchCase 
+:
+{ before(grammarAccess.getSwitchCaseRule()); }
+	 ruleSwitchCase
+{ after(grammarAccess.getSwitchCaseRule()); } 
+	 EOF 
+;
+
+// Rule SwitchCase
+ruleSwitchCase
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSwitchCaseAccess().getGroup()); }
+(rule__SwitchCase__Group__0)
+{ after(grammarAccess.getSwitchCaseAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSwitchDefaultClause
+entryRuleSwitchDefaultClause 
+:
+{ before(grammarAccess.getSwitchDefaultClauseRule()); }
+	 ruleSwitchDefaultClause
+{ after(grammarAccess.getSwitchDefaultClauseRule()); } 
+	 EOF 
+;
+
+// Rule SwitchDefaultClause
+ruleSwitchDefaultClause
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSwitchDefaultClauseAccess().getGroup()); }
+(rule__SwitchDefaultClause__Group__0)
+{ after(grammarAccess.getSwitchDefaultClauseAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNonEmptyStatementSequence
+entryRuleNonEmptyStatementSequence 
+:
+{ before(grammarAccess.getNonEmptyStatementSequenceRule()); }
+	 ruleNonEmptyStatementSequence
+{ after(grammarAccess.getNonEmptyStatementSequenceRule()); } 
+	 EOF 
+;
+
+// Rule NonEmptyStatementSequence
+ruleNonEmptyStatementSequence
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+(
+{ before(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment()); }
+(rule__NonEmptyStatementSequence__StatementAssignment)
+{ after(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment()); }
+)
+(
+{ before(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment()); }
+(rule__NonEmptyStatementSequence__StatementAssignment)*
+{ after(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment()); }
+)
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleWhileStatement
+entryRuleWhileStatement 
+:
+{ before(grammarAccess.getWhileStatementRule()); }
+	 ruleWhileStatement
+{ after(grammarAccess.getWhileStatementRule()); } 
+	 EOF 
+;
+
+// Rule WhileStatement
+ruleWhileStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getWhileStatementAccess().getGroup()); }
+(rule__WhileStatement__Group__0)
+{ after(grammarAccess.getWhileStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleDoStatement
+entryRuleDoStatement 
+:
+{ before(grammarAccess.getDoStatementRule()); }
+	 ruleDoStatement
+{ after(grammarAccess.getDoStatementRule()); } 
+	 EOF 
+;
+
+// Rule DoStatement
+ruleDoStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getDoStatementAccess().getGroup()); }
+(rule__DoStatement__Group__0)
+{ after(grammarAccess.getDoStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleForStatement
+entryRuleForStatement 
+:
+{ before(grammarAccess.getForStatementRule()); }
+	 ruleForStatement
+{ after(grammarAccess.getForStatementRule()); } 
+	 EOF 
+;
+
+// Rule ForStatement
+ruleForStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getForStatementAccess().getGroup()); }
+(rule__ForStatement__Group__0)
+{ after(grammarAccess.getForStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleForControl
+entryRuleForControl 
+:
+{ before(grammarAccess.getForControlRule()); }
+	 ruleForControl
+{ after(grammarAccess.getForControlRule()); } 
+	 EOF 
+;
+
+// Rule ForControl
+ruleForControl
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getForControlAccess().getGroup()); }
+(rule__ForControl__Group__0)
+{ after(grammarAccess.getForControlAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLoopVariableDefinition
+entryRuleLoopVariableDefinition 
+:
+{ before(grammarAccess.getLoopVariableDefinitionRule()); }
+	 ruleLoopVariableDefinition
+{ after(grammarAccess.getLoopVariableDefinitionRule()); } 
+	 EOF 
+;
+
+// Rule LoopVariableDefinition
+ruleLoopVariableDefinition
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getAlternatives()); }
+(rule__LoopVariableDefinition__Alternatives)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleBreakStatement
+entryRuleBreakStatement 
+:
+{ before(grammarAccess.getBreakStatementRule()); }
+	 ruleBreakStatement
+{ after(grammarAccess.getBreakStatementRule()); } 
+	 EOF 
+;
+
+// Rule BreakStatement
+ruleBreakStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getBreakStatementAccess().getGroup()); }
+(rule__BreakStatement__Group__0)
+{ after(grammarAccess.getBreakStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleReturnStatement
+entryRuleReturnStatement 
+:
+{ before(grammarAccess.getReturnStatementRule()); }
+	 ruleReturnStatement
+{ after(grammarAccess.getReturnStatementRule()); } 
+	 EOF 
+;
+
+// Rule ReturnStatement
+ruleReturnStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getReturnStatementAccess().getGroup()); }
+(rule__ReturnStatement__Group__0)
+{ after(grammarAccess.getReturnStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAcceptStatement
+entryRuleAcceptStatement 
+:
+{ before(grammarAccess.getAcceptStatementRule()); }
+	 ruleAcceptStatement
+{ after(grammarAccess.getAcceptStatementRule()); } 
+	 EOF 
+;
+
+// Rule AcceptStatement
+ruleAcceptStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getAcceptStatementAccess().getGroup()); }
+(rule__AcceptStatement__Group__0)
+{ after(grammarAccess.getAcceptStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSimpleAcceptStatementCompletion
+entryRuleSimpleAcceptStatementCompletion 
+:
+{ before(grammarAccess.getSimpleAcceptStatementCompletionRule()); }
+	 ruleSimpleAcceptStatementCompletion
+{ after(grammarAccess.getSimpleAcceptStatementCompletionRule()); } 
+	 EOF 
+;
+
+// Rule SimpleAcceptStatementCompletion
+ruleSimpleAcceptStatementCompletion
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSimpleAcceptStatementCompletionAccess().getGroup()); }
+(rule__SimpleAcceptStatementCompletion__Group__0)
+{ after(grammarAccess.getSimpleAcceptStatementCompletionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleCompoundAcceptStatementCompletion
+entryRuleCompoundAcceptStatementCompletion 
+:
+{ before(grammarAccess.getCompoundAcceptStatementCompletionRule()); }
+	 ruleCompoundAcceptStatementCompletion
+{ after(grammarAccess.getCompoundAcceptStatementCompletionRule()); } 
+	 EOF 
+;
+
+// Rule CompoundAcceptStatementCompletion
+ruleCompoundAcceptStatementCompletion
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup()); }
+(rule__CompoundAcceptStatementCompletion__Group__0)
+{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAcceptBlock
+entryRuleAcceptBlock 
+:
+{ before(grammarAccess.getAcceptBlockRule()); }
+	 ruleAcceptBlock
+{ after(grammarAccess.getAcceptBlockRule()); } 
+	 EOF 
+;
+
+// Rule AcceptBlock
+ruleAcceptBlock
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getAcceptBlockAccess().getGroup()); }
+(rule__AcceptBlock__Group__0)
+{ after(grammarAccess.getAcceptBlockAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAcceptClause
+entryRuleAcceptClause 
+:
+{ before(grammarAccess.getAcceptClauseRule()); }
+	 ruleAcceptClause
+{ after(grammarAccess.getAcceptClauseRule()); } 
+	 EOF 
+;
+
+// Rule AcceptClause
+ruleAcceptClause
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getGroup()); }
+(rule__AcceptClause__Group__0)
+{ after(grammarAccess.getAcceptClauseAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleClassifyStatement
+entryRuleClassifyStatement 
+:
+{ before(grammarAccess.getClassifyStatementRule()); }
+	 ruleClassifyStatement
+{ after(grammarAccess.getClassifyStatementRule()); } 
+	 EOF 
+;
+
+// Rule ClassifyStatement
+ruleClassifyStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getClassifyStatementAccess().getGroup()); }
+(rule__ClassifyStatement__Group__0)
+{ after(grammarAccess.getClassifyStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleClassificationClause
+entryRuleClassificationClause 
+:
+{ before(grammarAccess.getClassificationClauseRule()); }
+	 ruleClassificationClause
+{ after(grammarAccess.getClassificationClauseRule()); } 
+	 EOF 
+;
+
+// Rule ClassificationClause
+ruleClassificationClause
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getAlternatives()); }
+(rule__ClassificationClause__Alternatives)
+{ after(grammarAccess.getClassificationClauseAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleClassificationFromClause
+entryRuleClassificationFromClause 
+:
+{ before(grammarAccess.getClassificationFromClauseRule()); }
+	 ruleClassificationFromClause
+{ after(grammarAccess.getClassificationFromClauseRule()); } 
+	 EOF 
+;
+
+// Rule ClassificationFromClause
+ruleClassificationFromClause
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getClassificationFromClauseAccess().getGroup()); }
+(rule__ClassificationFromClause__Group__0)
+{ after(grammarAccess.getClassificationFromClauseAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleClassificationToClause
+entryRuleClassificationToClause 
+:
+{ before(grammarAccess.getClassificationToClauseRule()); }
+	 ruleClassificationToClause
+{ after(grammarAccess.getClassificationToClauseRule()); } 
+	 EOF 
+;
+
+// Rule ClassificationToClause
+ruleClassificationToClause
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getClassificationToClauseAccess().getGroup()); }
+(rule__ClassificationToClause__Group__0)
+{ after(grammarAccess.getClassificationToClauseAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleReclassifyAllClause
+entryRuleReclassifyAllClause 
+:
+{ before(grammarAccess.getReclassifyAllClauseRule()); }
+	 ruleReclassifyAllClause
+{ after(grammarAccess.getReclassifyAllClauseRule()); } 
+	 EOF 
+;
+
+// Rule ReclassifyAllClause
+ruleReclassifyAllClause
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getReclassifyAllClauseAccess().getGroup()); }
+(rule__ReclassifyAllClause__Group__0)
+{ after(grammarAccess.getReclassifyAllClauseAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleQualifiedNameList
+entryRuleQualifiedNameList 
+:
+{ before(grammarAccess.getQualifiedNameListRule()); }
+	 ruleQualifiedNameList
+{ after(grammarAccess.getQualifiedNameListRule()); } 
+	 EOF 
+;
+
+// Rule QualifiedNameList
+ruleQualifiedNameList
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getGroup()); }
+(rule__QualifiedNameList__Group__0)
+{ after(grammarAccess.getQualifiedNameListAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInvocationOrAssignementOrDeclarationStatement
+entryRuleInvocationOrAssignementOrDeclarationStatement 
+:
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementRule()); }
+	 ruleInvocationOrAssignementOrDeclarationStatement
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementRule()); } 
+	 EOF 
+;
+
+// Rule InvocationOrAssignementOrDeclarationStatement
+ruleInvocationOrAssignementOrDeclarationStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getGroup()); }
+(rule__InvocationOrAssignementOrDeclarationStatement__Group__0)
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSuperInvocationStatement
+entryRuleSuperInvocationStatement 
+:
+{ before(grammarAccess.getSuperInvocationStatementRule()); }
+	 ruleSuperInvocationStatement
+{ after(grammarAccess.getSuperInvocationStatementRule()); } 
+	 EOF 
+;
+
+// Rule SuperInvocationStatement
+ruleSuperInvocationStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSuperInvocationStatementAccess().getGroup()); }
+(rule__SuperInvocationStatement__Group__0)
+{ after(grammarAccess.getSuperInvocationStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleThisInvocationStatement
+entryRuleThisInvocationStatement 
+:
+{ before(grammarAccess.getThisInvocationStatementRule()); }
+	 ruleThisInvocationStatement
+{ after(grammarAccess.getThisInvocationStatementRule()); } 
+	 EOF 
+;
+
+// Rule ThisInvocationStatement
+ruleThisInvocationStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getThisInvocationStatementAccess().getGroup()); }
+(rule__ThisInvocationStatement__Group__0)
+{ after(grammarAccess.getThisInvocationStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleInstanceCreationInvocationStatement
+entryRuleInstanceCreationInvocationStatement 
+:
+{ before(grammarAccess.getInstanceCreationInvocationStatementRule()); }
+	 ruleInstanceCreationInvocationStatement
+{ after(grammarAccess.getInstanceCreationInvocationStatementRule()); } 
+	 EOF 
+;
+
+// Rule InstanceCreationInvocationStatement
+ruleInstanceCreationInvocationStatement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getInstanceCreationInvocationStatementAccess().getGroup()); }
+(rule__InstanceCreationInvocationStatement__Group__0)
+{ after(grammarAccess.getInstanceCreationInvocationStatementAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleVariableDeclarationCompletion
+entryRuleVariableDeclarationCompletion 
+:
+{ before(grammarAccess.getVariableDeclarationCompletionRule()); }
+	 ruleVariableDeclarationCompletion
+{ after(grammarAccess.getVariableDeclarationCompletionRule()); } 
+	 EOF 
+;
+
+// Rule VariableDeclarationCompletion
+ruleVariableDeclarationCompletion
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getGroup()); }
+(rule__VariableDeclarationCompletion__Group__0)
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleAssignmentCompletion
+entryRuleAssignmentCompletion 
+:
+{ before(grammarAccess.getAssignmentCompletionRule()); }
+	 ruleAssignmentCompletion
+{ after(grammarAccess.getAssignmentCompletionRule()); } 
+	 EOF 
+;
+
+// Rule AssignmentCompletion
+ruleAssignmentCompletion
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getAssignmentCompletionAccess().getGroup()); }
+(rule__AssignmentCompletion__Group__0)
+{ after(grammarAccess.getAssignmentCompletionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+// Rule BooleanValue
+ruleBooleanValue
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getBooleanValueAccess().getAlternatives()); }
+(rule__BooleanValue__Alternatives)
+{ after(grammarAccess.getBooleanValueAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Rule LinkOperationKind
+ruleLinkOperationKind
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationKindAccess().getAlternatives()); }
+(rule__LinkOperationKind__Alternatives)
+{ after(grammarAccess.getLinkOperationKindAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Rule SelectOrRejectOperator
+ruleSelectOrRejectOperator
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperatorAccess().getAlternatives()); }
+(rule__SelectOrRejectOperator__Alternatives)
+{ after(grammarAccess.getSelectOrRejectOperatorAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Rule CollectOrIterateOperator
+ruleCollectOrIterateOperator
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperatorAccess().getAlternatives()); }
+(rule__CollectOrIterateOperator__Alternatives)
+{ after(grammarAccess.getCollectOrIterateOperatorAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Rule ForAllOrExistsOrOneOperator
+ruleForAllOrExistsOrOneOperator
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getAlternatives()); }
+(rule__ForAllOrExistsOrOneOperator__Alternatives)
+{ after(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Rule AnnotationKind
+ruleAnnotationKind
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotationKindAccess().getAlternatives()); }
+(rule__AnnotationKind__Alternatives)
+{ after(grammarAccess.getAnnotationKindAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Rule AssignmentOperator
+ruleAssignmentOperator
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAssignmentOperatorAccess().getAlternatives()); }
+(rule__AssignmentOperator__Alternatives)
+{ after(grammarAccess.getAssignmentOperatorAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+rule__LITERAL__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLITERALAccess().getBOOLEAN_LITERALParserRuleCall_0()); }
+	ruleBOOLEAN_LITERAL
+{ after(grammarAccess.getLITERALAccess().getBOOLEAN_LITERALParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getLITERALAccess().getNUMBER_LITERALParserRuleCall_1()); }
+	ruleNUMBER_LITERAL
+{ after(grammarAccess.getLITERALAccess().getNUMBER_LITERALParserRuleCall_1()); }
+)
+
+    |(
+{ before(grammarAccess.getLITERALAccess().getSTRING_LITERALParserRuleCall_2()); }
+	ruleSTRING_LITERAL
+{ after(grammarAccess.getLITERALAccess().getSTRING_LITERALParserRuleCall_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NUMBER_LITERAL__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNUMBER_LITERALAccess().getINTEGER_LITERALParserRuleCall_0()); }
+	ruleINTEGER_LITERAL
+{ after(grammarAccess.getNUMBER_LITERALAccess().getINTEGER_LITERALParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getNUMBER_LITERALAccess().getUNLIMITED_LITERALParserRuleCall_1()); }
+	ruleUNLIMITED_LITERAL
+{ after(grammarAccess.getNUMBER_LITERALAccess().getUNLIMITED_LITERALParserRuleCall_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Alternatives_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getGroup_0_0()); }
+(rule__NameExpression__Group_0_0__0)
+{ after(grammarAccess.getNameExpressionAccess().getGroup_0_0()); }
+)
+
+    |(
+{ before(grammarAccess.getNameExpressionAccess().getGroup_0_1()); }
+(rule__NameExpression__Group_0_1__0)
+{ after(grammarAccess.getNameExpressionAccess().getGroup_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__PrefixOpAlternatives_0_0_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPrefixOpPlusSignPlusSignKeyword_0_0_0_0_0()); }
+
+	'++' 
+
+{ after(grammarAccess.getNameExpressionAccess().getPrefixOpPlusSignPlusSignKeyword_0_0_0_0_0()); }
+)
+
+    |(
+{ before(grammarAccess.getNameExpressionAccess().getPrefixOpHyphenMinusHyphenMinusKeyword_0_0_0_0_1()); }
+
+	'--' 
+
+{ after(grammarAccess.getNameExpressionAccess().getPrefixOpHyphenMinusHyphenMinusKeyword_0_0_0_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Alternatives_0_1_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getInvocationCompletionAssignment_0_1_2_0()); }
+(rule__NameExpression__InvocationCompletionAssignment_0_1_2_0)
+{ after(grammarAccess.getNameExpressionAccess().getInvocationCompletionAssignment_0_1_2_0()); }
+)
+
+    |(
+{ before(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionAssignment_0_1_2_1()); }
+(rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1)
+{ after(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionAssignment_0_1_2_1()); }
+)
+
+    |(
+{ before(grammarAccess.getNameExpressionAccess().getPostfixOpAssignment_0_1_2_2()); }
+(rule__NameExpression__PostfixOpAssignment_0_1_2_2)
+{ after(grammarAccess.getNameExpressionAccess().getPostfixOpAssignment_0_1_2_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPostfixOpPlusSignPlusSignKeyword_0_1_2_2_0_0()); }
+
+	'++' 
+
+{ after(grammarAccess.getNameExpressionAccess().getPostfixOpPlusSignPlusSignKeyword_0_1_2_2_0_0()); }
+)
+
+    |(
+{ before(grammarAccess.getNameExpressionAccess().getPostfixOpHyphenMinusHyphenMinusKeyword_0_1_2_2_0_1()); }
+
+	'--' 
+
+{ after(grammarAccess.getNameExpressionAccess().getPostfixOpHyphenMinusHyphenMinusKeyword_0_1_2_2_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__OpAlternatives_1_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getOpEqualsSignEqualsSignKeyword_1_0_0_0()); }
+
+	'==' 
+
+{ after(grammarAccess.getEqualityExpressionAccess().getOpEqualsSignEqualsSignKeyword_1_0_0_0()); }
+)
+
+    |(
+{ before(grammarAccess.getEqualityExpressionAccess().getOpExclamationMarkEqualsSignKeyword_1_0_0_1()); }
+
+	'!=' 
+
+{ after(grammarAccess.getEqualityExpressionAccess().getOpExclamationMarkEqualsSignKeyword_1_0_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__OpAlternatives_1_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getOpInstanceofKeyword_1_0_0_0()); }
+
+	'instanceof' 
+
+{ after(grammarAccess.getClassificationExpressionAccess().getOpInstanceofKeyword_1_0_0_0()); }
+)
+
+    |(
+{ before(grammarAccess.getClassificationExpressionAccess().getOpHastypeKeyword_1_0_0_1()); }
+
+	'hastype' 
+
+{ after(grammarAccess.getClassificationExpressionAccess().getOpHastypeKeyword_1_0_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__RelationalExpression__OpAlternatives_1_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getOpLessThanSignKeyword_1_0_0_0()); }
+
+	'<' 
+
+{ after(grammarAccess.getRelationalExpressionAccess().getOpLessThanSignKeyword_1_0_0_0()); }
+)
+
+    |(
+{ before(grammarAccess.getRelationalExpressionAccess().getOpGreaterThanSignKeyword_1_0_0_1()); }
+
+	'>' 
+
+{ after(grammarAccess.getRelationalExpressionAccess().getOpGreaterThanSignKeyword_1_0_0_1()); }
+)
+
+    |(
+{ before(grammarAccess.getRelationalExpressionAccess().getOpLessThanSignEqualsSignKeyword_1_0_0_2()); }
+
+	'<=' 
+
+{ after(grammarAccess.getRelationalExpressionAccess().getOpLessThanSignEqualsSignKeyword_1_0_0_2()); }
+)
+
+    |(
+{ before(grammarAccess.getRelationalExpressionAccess().getOpGreaterThanSignEqualsSignKeyword_1_0_0_3()); }
+
+	'>=' 
+
+{ after(grammarAccess.getRelationalExpressionAccess().getOpGreaterThanSignEqualsSignKeyword_1_0_0_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__OpAlternatives_1_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getOpLessThanSignLessThanSignKeyword_1_0_0_0()); }
+
+	'<<' 
+
+{ after(grammarAccess.getShiftExpressionAccess().getOpLessThanSignLessThanSignKeyword_1_0_0_0()); }
+)
+
+    |(
+{ before(grammarAccess.getShiftExpressionAccess().getOpGreaterThanSignGreaterThanSignKeyword_1_0_0_1()); }
+
+	'>>' 
+
+{ after(grammarAccess.getShiftExpressionAccess().getOpGreaterThanSignGreaterThanSignKeyword_1_0_0_1()); }
+)
+
+    |(
+{ before(grammarAccess.getShiftExpressionAccess().getOpGreaterThanSignGreaterThanSignGreaterThanSignKeyword_1_0_0_2()); }
+
+	'>>>' 
+
+{ after(grammarAccess.getShiftExpressionAccess().getOpGreaterThanSignGreaterThanSignGreaterThanSignKeyword_1_0_0_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AdditiveExpression__OpAlternatives_1_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getOpPlusSignKeyword_1_0_0_0()); }
+
+	'+' 
+
+{ after(grammarAccess.getAdditiveExpressionAccess().getOpPlusSignKeyword_1_0_0_0()); }
+)
+
+    |(
+{ before(grammarAccess.getAdditiveExpressionAccess().getOpHyphenMinusKeyword_1_0_0_1()); }
+
+	'-' 
+
+{ after(grammarAccess.getAdditiveExpressionAccess().getOpHyphenMinusKeyword_1_0_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__MultiplicativeExpression__OpAlternatives_1_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getOpAsteriskKeyword_1_0_0_0()); }
+
+	'*' 
+
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getOpAsteriskKeyword_1_0_0_0()); }
+)
+
+    |(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getOpSolidusKeyword_1_0_0_1()); }
+
+	'/' 
+
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getOpSolidusKeyword_1_0_0_1()); }
+)
+
+    |(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getOpPercentSignKeyword_1_0_0_2()); }
+
+	'%' 
+
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getOpPercentSignKeyword_1_0_0_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__UnaryExpression__OpAlternatives_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getUnaryExpressionAccess().getOpExclamationMarkKeyword_0_0_0()); }
+
+	'!' 
+
+{ after(grammarAccess.getUnaryExpressionAccess().getOpExclamationMarkKeyword_0_0_0()); }
+)
+
+    |(
+{ before(grammarAccess.getUnaryExpressionAccess().getOpHyphenMinusKeyword_0_0_1()); }
+
+	'-' 
+
+{ after(grammarAccess.getUnaryExpressionAccess().getOpHyphenMinusKeyword_0_0_1()); }
+)
+
+    |(
+{ before(grammarAccess.getUnaryExpressionAccess().getOpPlusSignKeyword_0_0_2()); }
+
+	'+' 
+
+{ after(grammarAccess.getUnaryExpressionAccess().getOpPlusSignKeyword_0_0_2()); }
+)
+
+    |(
+{ before(grammarAccess.getUnaryExpressionAccess().getOpDollarSignKeyword_0_0_3()); }
+
+	'$' 
+
+{ after(grammarAccess.getUnaryExpressionAccess().getOpDollarSignKeyword_0_0_3()); }
+)
+
+    |(
+{ before(grammarAccess.getUnaryExpressionAccess().getOpTildeKeyword_0_0_4()); }
+
+	'~' 
+
+{ after(grammarAccess.getUnaryExpressionAccess().getOpTildeKeyword_0_0_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SuffixExpression__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSuffixExpressionAccess().getOperationCallExpressionParserRuleCall_0()); }
+	ruleOperationCallExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getOperationCallExpressionParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getSuffixExpressionAccess().getPropertyCallExpressionParserRuleCall_1()); }
+	rulePropertyCallExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getPropertyCallExpressionParserRuleCall_1()); }
+)
+
+    |(
+{ before(grammarAccess.getSuffixExpressionAccess().getLinkOperationExpressionParserRuleCall_2()); }
+	ruleLinkOperationExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getLinkOperationExpressionParserRuleCall_2()); }
+)
+
+    |(
+{ before(grammarAccess.getSuffixExpressionAccess().getSequenceOperationExpressionParserRuleCall_3()); }
+	ruleSequenceOperationExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getSequenceOperationExpressionParserRuleCall_3()); }
+)
+
+    |(
+{ before(grammarAccess.getSuffixExpressionAccess().getSequenceReductionExpressionParserRuleCall_4()); }
+	ruleSequenceReductionExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getSequenceReductionExpressionParserRuleCall_4()); }
+)
+
+    |(
+{ before(grammarAccess.getSuffixExpressionAccess().getSequenceExpansionExpressionParserRuleCall_5()); }
+	ruleSequenceExpansionExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getSequenceExpansionExpressionParserRuleCall_5()); }
+)
+
+    |(
+{ before(grammarAccess.getSuffixExpressionAccess().getClassExtentExpressionParserRuleCall_6()); }
+	ruleClassExtentExpression
+{ after(grammarAccess.getSuffixExpressionAccess().getClassExtentExpressionParserRuleCall_6()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceExpansionExpression__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceExpansionExpressionAccess().getSelectOrRejectOperationParserRuleCall_0()); }
+	ruleSelectOrRejectOperation
+{ after(grammarAccess.getSequenceExpansionExpressionAccess().getSelectOrRejectOperationParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getSequenceExpansionExpressionAccess().getCollectOrIterateOperationParserRuleCall_1()); }
+	ruleCollectOrIterateOperation
+{ after(grammarAccess.getSequenceExpansionExpressionAccess().getCollectOrIterateOperationParserRuleCall_1()); }
+)
+
+    |(
+{ before(grammarAccess.getSequenceExpansionExpressionAccess().getForAllOrExistsOrOneOperationParserRuleCall_2()); }
+	ruleForAllOrExistsOrOneOperation
+{ after(grammarAccess.getSequenceExpansionExpressionAccess().getForAllOrExistsOrOneOperationParserRuleCall_2()); }
+)
+
+    |(
+{ before(grammarAccess.getSequenceExpansionExpressionAccess().getIsUniqueOperationParserRuleCall_3()); }
+	ruleIsUniqueOperation
+{ after(grammarAccess.getSequenceExpansionExpressionAccess().getIsUniqueOperationParserRuleCall_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ValueSpecification__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getValueSpecificationAccess().getNameExpressionParserRuleCall_0()); }
+	ruleNameExpression
+{ after(grammarAccess.getValueSpecificationAccess().getNameExpressionParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getValueSpecificationAccess().getLITERALParserRuleCall_1()); }
+	ruleLITERAL
+{ after(grammarAccess.getValueSpecificationAccess().getLITERALParserRuleCall_1()); }
+)
+
+    |(
+{ before(grammarAccess.getValueSpecificationAccess().getThisExpressionParserRuleCall_2()); }
+	ruleThisExpression
+{ after(grammarAccess.getValueSpecificationAccess().getThisExpressionParserRuleCall_2()); }
+)
+
+    |(
+{ before(grammarAccess.getValueSpecificationAccess().getSuperInvocationExpressionParserRuleCall_3()); }
+	ruleSuperInvocationExpression
+{ after(grammarAccess.getValueSpecificationAccess().getSuperInvocationExpressionParserRuleCall_3()); }
+)
+
+    |(
+{ before(grammarAccess.getValueSpecificationAccess().getInstanceCreationExpressionParserRuleCall_4()); }
+	ruleInstanceCreationExpression
+{ after(grammarAccess.getValueSpecificationAccess().getInstanceCreationExpressionParserRuleCall_4()); }
+)
+
+    |(
+{ before(grammarAccess.getValueSpecificationAccess().getParenthesizedExpressionParserRuleCall_5()); }
+	ruleParenthesizedExpression
+{ after(grammarAccess.getValueSpecificationAccess().getParenthesizedExpressionParserRuleCall_5()); }
+)
+
+    |(
+{ before(grammarAccess.getValueSpecificationAccess().getNullExpressionParserRuleCall_6()); }
+	ruleNullExpression
+{ after(grammarAccess.getValueSpecificationAccess().getNullExpressionParserRuleCall_6()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NonLiteralValueSpecification__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNonLiteralValueSpecificationAccess().getNameExpressionParserRuleCall_0()); }
+	ruleNameExpression
+{ after(grammarAccess.getNonLiteralValueSpecificationAccess().getNameExpressionParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getNonLiteralValueSpecificationAccess().getParenthesizedExpressionParserRuleCall_1()); }
+	ruleParenthesizedExpression
+{ after(grammarAccess.getNonLiteralValueSpecificationAccess().getParenthesizedExpressionParserRuleCall_1()); }
+)
+
+    |(
+{ before(grammarAccess.getNonLiteralValueSpecificationAccess().getInstanceCreationExpressionParserRuleCall_2()); }
+	ruleInstanceCreationExpression
+{ after(grammarAccess.getNonLiteralValueSpecificationAccess().getInstanceCreationExpressionParserRuleCall_2()); }
+)
+
+    |(
+{ before(grammarAccess.getNonLiteralValueSpecificationAccess().getThisExpressionParserRuleCall_3()); }
+	ruleThisExpression
+{ after(grammarAccess.getNonLiteralValueSpecificationAccess().getThisExpressionParserRuleCall_3()); }
+)
+
+    |(
+{ before(grammarAccess.getNonLiteralValueSpecificationAccess().getSuperInvocationExpressionParserRuleCall_4()); }
+	ruleSuperInvocationExpression
+{ after(grammarAccess.getNonLiteralValueSpecificationAccess().getSuperInvocationExpressionParserRuleCall_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__Alternatives_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getCastedAssignment_3_0()); }
+(rule__ParenthesizedExpression__CastedAssignment_3_0)
+{ after(grammarAccess.getParenthesizedExpressionAccess().getCastedAssignment_3_0()); }
+)
+
+    |(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getSuffixAssignment_3_1()); }
+(rule__ParenthesizedExpression__SuffixAssignment_3_1)
+{ after(grammarAccess.getParenthesizedExpressionAccess().getSuffixAssignment_3_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__Alternatives_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_0()); }
+(rule__SuperInvocationExpression__TupleAssignment_1_0)
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_0()); }
+)
+
+    |(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getGroup_1_1()); }
+(rule__SuperInvocationExpression__Group_1_1__0)
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getGroup_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getGroup_0()); }
+(rule__SequenceConstructionOrAccessCompletion__Group_0__0)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getGroup_0()); }
+)
+
+    |(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionAssignment_1()); }
+(rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAssignment_0_1_0()); }
+(rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAssignment_0_1_0()); }
+)
+
+    |(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionAssignment_0_1_1()); }
+(rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionAssignment_0_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Alternatives_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_0()); }
+(rule__SequenceConstructionExpression__Group_2_0__0)*
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_0()); }
+)
+
+    |(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_1()); }
+(rule__SequenceConstructionExpression__Group_2_1__0)
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceElement__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceElementAccess().getExpressionParserRuleCall_0()); }
+	ruleExpression
+{ after(grammarAccess.getSequenceElementAccess().getExpressionParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getSequenceElementAccess().getSequenceConstructionExpressionParserRuleCall_1()); }
+	ruleSequenceConstructionExpression
+{ after(grammarAccess.getSequenceElementAccess().getSequenceConstructionExpressionParserRuleCall_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DocumentedStatement__CommentAlternatives_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDocumentedStatementAccess().getCommentML_COMMENTTerminalRuleCall_0_0_0()); }
+	RULE_ML_COMMENT
+{ after(grammarAccess.getDocumentedStatementAccess().getCommentML_COMMENTTerminalRuleCall_0_0_0()); }
+)
+
+    |(
+{ before(grammarAccess.getDocumentedStatementAccess().getCommentSL_COMMENTTerminalRuleCall_0_0_1()); }
+	RULE_SL_COMMENT
+{ after(grammarAccess.getDocumentedStatementAccess().getCommentSL_COMMENTTerminalRuleCall_0_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Statement__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getStatementAccess().getAnnotatedStatementParserRuleCall_0()); }
+	ruleAnnotatedStatement
+{ after(grammarAccess.getStatementAccess().getAnnotatedStatementParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getInlineStatementParserRuleCall_1()); }
+	ruleInlineStatement
+{ after(grammarAccess.getStatementAccess().getInlineStatementParserRuleCall_1()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getBlockStatementParserRuleCall_2()); }
+	ruleBlockStatement
+{ after(grammarAccess.getStatementAccess().getBlockStatementParserRuleCall_2()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getEmptyStatementParserRuleCall_3()); }
+	ruleEmptyStatement
+{ after(grammarAccess.getStatementAccess().getEmptyStatementParserRuleCall_3()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getLocalNameDeclarationStatementParserRuleCall_4()); }
+	ruleLocalNameDeclarationStatement
+{ after(grammarAccess.getStatementAccess().getLocalNameDeclarationStatementParserRuleCall_4()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getIfStatementParserRuleCall_5()); }
+	ruleIfStatement
+{ after(grammarAccess.getStatementAccess().getIfStatementParserRuleCall_5()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getSwitchStatementParserRuleCall_6()); }
+	ruleSwitchStatement
+{ after(grammarAccess.getStatementAccess().getSwitchStatementParserRuleCall_6()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getWhileStatementParserRuleCall_7()); }
+	ruleWhileStatement
+{ after(grammarAccess.getStatementAccess().getWhileStatementParserRuleCall_7()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getDoStatementParserRuleCall_8()); }
+	ruleDoStatement
+{ after(grammarAccess.getStatementAccess().getDoStatementParserRuleCall_8()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getForStatementParserRuleCall_9()); }
+	ruleForStatement
+{ after(grammarAccess.getStatementAccess().getForStatementParserRuleCall_9()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getBreakStatementParserRuleCall_10()); }
+	ruleBreakStatement
+{ after(grammarAccess.getStatementAccess().getBreakStatementParserRuleCall_10()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getReturnStatementParserRuleCall_11()); }
+	ruleReturnStatement
+{ after(grammarAccess.getStatementAccess().getReturnStatementParserRuleCall_11()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getAcceptStatementParserRuleCall_12()); }
+	ruleAcceptStatement
+{ after(grammarAccess.getStatementAccess().getAcceptStatementParserRuleCall_12()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getClassifyStatementParserRuleCall_13()); }
+	ruleClassifyStatement
+{ after(grammarAccess.getStatementAccess().getClassifyStatementParserRuleCall_13()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getInvocationOrAssignementOrDeclarationStatementParserRuleCall_14()); }
+	ruleInvocationOrAssignementOrDeclarationStatement
+{ after(grammarAccess.getStatementAccess().getInvocationOrAssignementOrDeclarationStatementParserRuleCall_14()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getSuperInvocationStatementParserRuleCall_15()); }
+	ruleSuperInvocationStatement
+{ after(grammarAccess.getStatementAccess().getSuperInvocationStatementParserRuleCall_15()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getThisInvocationStatementParserRuleCall_16()); }
+	ruleThisInvocationStatement
+{ after(grammarAccess.getStatementAccess().getThisInvocationStatementParserRuleCall_16()); }
+)
+
+    |(
+{ before(grammarAccess.getStatementAccess().getInstanceCreationInvocationStatementParserRuleCall_17()); }
+	ruleInstanceCreationInvocationStatement
+{ after(grammarAccess.getStatementAccess().getInstanceCreationInvocationStatementParserRuleCall_17()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0()); }
+(rule__LoopVariableDefinition__Group_0__0)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0()); }
+)
+
+    |(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getGroup_1()); }
+(rule__LoopVariableDefinition__Group_1__0)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptStatement__Alternatives_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptStatementAccess().getSimpleAcceptAssignment_1_0()); }
+(rule__AcceptStatement__SimpleAcceptAssignment_1_0)
+{ after(grammarAccess.getAcceptStatementAccess().getSimpleAcceptAssignment_1_0()); }
+)
+
+    |(
+{ before(grammarAccess.getAcceptStatementAccess().getCompoundAcceptAssignment_1_1()); }
+(rule__AcceptStatement__CompoundAcceptAssignment_1_1)
+{ after(grammarAccess.getAcceptStatementAccess().getCompoundAcceptAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getGroup_0()); }
+(rule__ClassificationClause__Group_0__0)
+{ after(grammarAccess.getClassificationClauseAccess().getGroup_0()); }
+)
+
+    |(
+{ before(grammarAccess.getClassificationClauseAccess().getGroup_1()); }
+(rule__ClassificationClause__Group_1__0)
+{ after(grammarAccess.getClassificationClauseAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionAssignment_1_0()); }
+(rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0)
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionAssignment_1_0()); }
+)
+
+    |(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignment_1_1()); }
+(rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1)
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__BooleanValue__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getBooleanValueAccess().getTRUEEnumLiteralDeclaration_0()); }
+(	'true' 
+)
+{ after(grammarAccess.getBooleanValueAccess().getTRUEEnumLiteralDeclaration_0()); }
+)
+
+    |(
+{ before(grammarAccess.getBooleanValueAccess().getFALSEEnumLiteralDeclaration_1()); }
+(	'false' 
+)
+{ after(grammarAccess.getBooleanValueAccess().getFALSEEnumLiteralDeclaration_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationKind__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationKindAccess().getCREATEEnumLiteralDeclaration_0()); }
+(	'createLink' 
+)
+{ after(grammarAccess.getLinkOperationKindAccess().getCREATEEnumLiteralDeclaration_0()); }
+)
+
+    |(
+{ before(grammarAccess.getLinkOperationKindAccess().getDESTROYEnumLiteralDeclaration_1()); }
+(	'destroyLink' 
+)
+{ after(grammarAccess.getLinkOperationKindAccess().getDESTROYEnumLiteralDeclaration_1()); }
+)
+
+    |(
+{ before(grammarAccess.getLinkOperationKindAccess().getCLEAREnumLiteralDeclaration_2()); }
+(	'clearAssoc' 
+)
+{ after(grammarAccess.getLinkOperationKindAccess().getCLEAREnumLiteralDeclaration_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperator__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperatorAccess().getSELECTEnumLiteralDeclaration_0()); }
+(	'select' 
+)
+{ after(grammarAccess.getSelectOrRejectOperatorAccess().getSELECTEnumLiteralDeclaration_0()); }
+)
+
+    |(
+{ before(grammarAccess.getSelectOrRejectOperatorAccess().getREJECTEnumLiteralDeclaration_1()); }
+(	'reject' 
+)
+{ after(grammarAccess.getSelectOrRejectOperatorAccess().getREJECTEnumLiteralDeclaration_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperator__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperatorAccess().getCOLLECTEnumLiteralDeclaration_0()); }
+(	'collect' 
+)
+{ after(grammarAccess.getCollectOrIterateOperatorAccess().getCOLLECTEnumLiteralDeclaration_0()); }
+)
+
+    |(
+{ before(grammarAccess.getCollectOrIterateOperatorAccess().getITERATEEnumLiteralDeclaration_1()); }
+(	'iterate' 
+)
+{ after(grammarAccess.getCollectOrIterateOperatorAccess().getITERATEEnumLiteralDeclaration_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperator__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getFORALLEnumLiteralDeclaration_0()); }
+(	'forAll' 
+)
+{ after(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getFORALLEnumLiteralDeclaration_0()); }
+)
+
+    |(
+{ before(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getEXISTSEnumLiteralDeclaration_1()); }
+(	'exists' 
+)
+{ after(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getEXISTSEnumLiteralDeclaration_1()); }
+)
+
+    |(
+{ before(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getONEEnumLiteralDeclaration_2()); }
+(	'one' 
+)
+{ after(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getONEEnumLiteralDeclaration_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AnnotationKind__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotationKindAccess().getISOLATEDEnumLiteralDeclaration_0()); }
+(	'isolated' 
+)
+{ after(grammarAccess.getAnnotationKindAccess().getISOLATEDEnumLiteralDeclaration_0()); }
+)
+
+    |(
+{ before(grammarAccess.getAnnotationKindAccess().getDETERMINEDEnumLiteralDeclaration_1()); }
+(	'determined' 
+)
+{ after(grammarAccess.getAnnotationKindAccess().getDETERMINEDEnumLiteralDeclaration_1()); }
+)
+
+    |(
+{ before(grammarAccess.getAnnotationKindAccess().getASSUREDEnumLiteralDeclaration_2()); }
+(	'assured' 
+)
+{ after(grammarAccess.getAnnotationKindAccess().getASSUREDEnumLiteralDeclaration_2()); }
+)
+
+    |(
+{ before(grammarAccess.getAnnotationKindAccess().getPARALLELEnumLiteralDeclaration_3()); }
+(	'parallel' 
+)
+{ after(grammarAccess.getAnnotationKindAccess().getPARALLELEnumLiteralDeclaration_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AssignmentOperator__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAssignmentOperatorAccess().getASSIGNEnumLiteralDeclaration_0()); }
+(	'=' 
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getASSIGNEnumLiteralDeclaration_0()); }
+)
+
+    |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getPLUSASSIGNEnumLiteralDeclaration_1()); }
+(	'+=' 
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getPLUSASSIGNEnumLiteralDeclaration_1()); }
+)
+
+    |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getMINUSASSIGNEnumLiteralDeclaration_2()); }
+(	'-=' 
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getMINUSASSIGNEnumLiteralDeclaration_2()); }
+)
+
+    |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getMULTASSIGNEnumLiteralDeclaration_3()); }
+(	'*=' 
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getMULTASSIGNEnumLiteralDeclaration_3()); }
+)
+
+    |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getMODASSIGNEnumLiteralDeclaration_4()); }
+(	'%=' 
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getMODASSIGNEnumLiteralDeclaration_4()); }
+)
+
+    |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getDIVASSIGNEnumLiteralDeclaration_5()); }
+(	'/=' 
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getDIVASSIGNEnumLiteralDeclaration_5()); }
+)
+
+    |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getANDASSIGNEnumLiteralDeclaration_6()); }
+(	'&=' 
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getANDASSIGNEnumLiteralDeclaration_6()); }
+)
+
+    |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getORASSIGNEnumLiteralDeclaration_7()); }
+(	'|=' 
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getORASSIGNEnumLiteralDeclaration_7()); }
+)
+
+    |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getXORASSIGNEnumLiteralDeclaration_8()); }
+(	'^=' 
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getXORASSIGNEnumLiteralDeclaration_8()); }
+)
+
+    |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getLSHIFTASSIGNEnumLiteralDeclaration_9()); }
+(	'<<=' 
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getLSHIFTASSIGNEnumLiteralDeclaration_9()); }
+)
+
+    |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getRSHIFTASSIGNEnumLiteralDeclaration_10()); }
+(	'>>=' 
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getRSHIFTASSIGNEnumLiteralDeclaration_10()); }
+)
+
+    |(
+{ before(grammarAccess.getAssignmentOperatorAccess().getURSHIFTASSIGNEnumLiteralDeclaration_11()); }
+(	'>>>=' 
+)
+{ after(grammarAccess.getAssignmentOperatorAccess().getURSHIFTASSIGNEnumLiteralDeclaration_11()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+rule__Test__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Test__Group__0__Impl
+	rule__Test__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getGroup_0()); }
+(rule__Test__Group_0__0)*
+{ after(grammarAccess.getTestAccess().getGroup_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Test__Group__1__Impl
+	rule__Test__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getGroup_1()); }
+(rule__Test__Group_1__0)*
+{ after(grammarAccess.getTestAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Test__Group__2__Impl
+	rule__Test__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getGroup_2()); }
+(rule__Test__Group_2__0)*
+{ after(grammarAccess.getTestAccess().getGroup_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Test__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getGroup_3()); }
+(rule__Test__Group_3__0)
+{ after(grammarAccess.getTestAccess().getGroup_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__Test__Group_0__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Test__Group_0__0__Impl
+	rule__Test__Group_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__Group_0__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getTestExpressionKeyword_0_0()); }
+
+	'testExpression' 
+
+{ after(grammarAccess.getTestAccess().getTestExpressionKeyword_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group_0__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Test__Group_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__Group_0__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getExpressionAssignment_0_1()); }
+(rule__Test__ExpressionAssignment_0_1)
+{ after(grammarAccess.getTestAccess().getExpressionAssignment_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Test__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Test__Group_1__0__Impl
+	rule__Test__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getTestAssignmentExpressionKeyword_1_0()); }
+
+	'testAssignmentExpression' 
+
+{ after(grammarAccess.getTestAccess().getTestAssignmentExpressionKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Test__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getAssignExpressionAssignment_1_1()); }
+(rule__Test__AssignExpressionAssignment_1_1)
+{ after(grammarAccess.getTestAccess().getAssignExpressionAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Test__Group_2__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Test__Group_2__0__Impl
+	rule__Test__Group_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__Group_2__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getTestStatementKeyword_2_0()); }
+
+	'testStatement' 
+
+{ after(grammarAccess.getTestAccess().getTestStatementKeyword_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group_2__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Test__Group_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__Group_2__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getStatementsAssignment_2_1()); }
+(rule__Test__StatementsAssignment_2_1)
+{ after(grammarAccess.getTestAccess().getStatementsAssignment_2_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Test__Group_3__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Test__Group_3__0__Impl
+	rule__Test__Group_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__Group_3__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getTestBlockKeyword_3_0()); }
+
+	'testBlock' 
+
+{ after(grammarAccess.getTestAccess().getTestBlockKeyword_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Test__Group_3__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Test__Group_3__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__Group_3__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getBlockAssignment_3_1()); }
+(rule__Test__BlockAssignment_3_1)
+{ after(grammarAccess.getTestAccess().getBlockAssignment_3_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__NameExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NameExpression__Group__0__Impl
+	rule__NameExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getAlternatives_0()); }
+(rule__NameExpression__Alternatives_0)
+{ after(grammarAccess.getNameExpressionAccess().getAlternatives_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__NameExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NameExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getSuffixAssignment_1()); }
+(rule__NameExpression__SuffixAssignment_1)?
+{ after(grammarAccess.getNameExpressionAccess().getSuffixAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__NameExpression__Group_0_0__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NameExpression__Group_0_0__0__Impl
+	rule__NameExpression__Group_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group_0_0__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPrefixOpAssignment_0_0_0()); }
+(rule__NameExpression__PrefixOpAssignment_0_0_0)
+{ after(grammarAccess.getNameExpressionAccess().getPrefixOpAssignment_0_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__NameExpression__Group_0_0__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NameExpression__Group_0_0__1__Impl
+	rule__NameExpression__Group_0_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group_0_0__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPathAssignment_0_0_1()); }
+(rule__NameExpression__PathAssignment_0_0_1)?
+{ after(grammarAccess.getNameExpressionAccess().getPathAssignment_0_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__NameExpression__Group_0_0__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NameExpression__Group_0_0__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group_0_0__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getIdAssignment_0_0_2()); }
+(rule__NameExpression__IdAssignment_0_0_2)
+{ after(grammarAccess.getNameExpressionAccess().getIdAssignment_0_0_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__NameExpression__Group_0_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NameExpression__Group_0_1__0__Impl
+	rule__NameExpression__Group_0_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group_0_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPathAssignment_0_1_0()); }
+(rule__NameExpression__PathAssignment_0_1_0)?
+{ after(grammarAccess.getNameExpressionAccess().getPathAssignment_0_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__NameExpression__Group_0_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NameExpression__Group_0_1__1__Impl
+	rule__NameExpression__Group_0_1__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group_0_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getIdAssignment_0_1_1()); }
+(rule__NameExpression__IdAssignment_0_1_1)
+{ after(grammarAccess.getNameExpressionAccess().getIdAssignment_0_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__NameExpression__Group_0_1__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NameExpression__Group_0_1__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__Group_0_1__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getAlternatives_0_1_2()); }
+(rule__NameExpression__Alternatives_0_1_2)?
+{ after(grammarAccess.getNameExpressionAccess().getAlternatives_0_1_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__QualifiedNamePath__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__QualifiedNamePath__Group__0__Impl
+	rule__QualifiedNamePath__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNamePath__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNamePathAccess().getNamespaceAssignment_0()); }
+(rule__QualifiedNamePath__NamespaceAssignment_0)
+{ after(grammarAccess.getQualifiedNamePathAccess().getNamespaceAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNamePath__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__QualifiedNamePath__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNamePath__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNamePathAccess().getColonColonKeyword_1()); }
+
+	'::' 
+
+{ after(grammarAccess.getQualifiedNamePathAccess().getColonColonKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__UnqualifiedName__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__UnqualifiedName__Group__0__Impl
+	rule__UnqualifiedName__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__UnqualifiedName__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getUnqualifiedNameAccess().getNameAssignment_0()); }
+(rule__UnqualifiedName__NameAssignment_0)
+{ after(grammarAccess.getUnqualifiedNameAccess().getNameAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__UnqualifiedName__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__UnqualifiedName__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__UnqualifiedName__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingAssignment_1()); }
+(rule__UnqualifiedName__TemplateBindingAssignment_1)?
+{ after(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TemplateBinding__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TemplateBinding__Group__0__Impl
+	rule__TemplateBinding__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getLessThanSignKeyword_0()); }
+
+	'<' 
+
+{ after(grammarAccess.getTemplateBindingAccess().getLessThanSignKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TemplateBinding__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TemplateBinding__Group__1__Impl
+	rule__TemplateBinding__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_1()); }
+(rule__TemplateBinding__BindingsAssignment_1)
+{ after(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TemplateBinding__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TemplateBinding__Group__2__Impl
+	rule__TemplateBinding__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getGroup_2()); }
+(rule__TemplateBinding__Group_2__0)*
+{ after(grammarAccess.getTemplateBindingAccess().getGroup_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TemplateBinding__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TemplateBinding__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getGreaterThanSignKeyword_3()); }
+
+	'>' 
+
+{ after(grammarAccess.getTemplateBindingAccess().getGreaterThanSignKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TemplateBinding__Group_2__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TemplateBinding__Group_2__0__Impl
+	rule__TemplateBinding__Group_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__Group_2__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getCommaKeyword_2_0()); }
+
+	',' 
+
+{ after(grammarAccess.getTemplateBindingAccess().getCommaKeyword_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TemplateBinding__Group_2__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TemplateBinding__Group_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__Group_2__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_2_1()); }
+(rule__TemplateBinding__BindingsAssignment_2_1)
+{ after(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_2_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__NamedTemplateBinding__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NamedTemplateBinding__Group__0__Impl
+	rule__NamedTemplateBinding__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NamedTemplateBinding__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNamedTemplateBindingAccess().getFormalAssignment_0()); }
+(rule__NamedTemplateBinding__FormalAssignment_0)
+{ after(grammarAccess.getNamedTemplateBindingAccess().getFormalAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__NamedTemplateBinding__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NamedTemplateBinding__Group__1__Impl
+	rule__NamedTemplateBinding__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NamedTemplateBinding__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNamedTemplateBindingAccess().getEqualsSignGreaterThanSignKeyword_1()); }
+
+	'=>' 
+
+{ after(grammarAccess.getNamedTemplateBindingAccess().getEqualsSignGreaterThanSignKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__NamedTemplateBinding__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NamedTemplateBinding__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NamedTemplateBinding__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNamedTemplateBindingAccess().getActualAssignment_2()); }
+(rule__NamedTemplateBinding__ActualAssignment_2)
+{ after(grammarAccess.getNamedTemplateBindingAccess().getActualAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__QualifiedNameWithBinding__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__QualifiedNameWithBinding__Group__0__Impl
+	rule__QualifiedNameWithBinding__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getIdAssignment_0()); }
+(rule__QualifiedNameWithBinding__IdAssignment_0)
+{ after(grammarAccess.getQualifiedNameWithBindingAccess().getIdAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameWithBinding__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__QualifiedNameWithBinding__Group__1__Impl
+	rule__QualifiedNameWithBinding__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getBindingAssignment_1()); }
+(rule__QualifiedNameWithBinding__BindingAssignment_1)?
+{ after(grammarAccess.getQualifiedNameWithBindingAccess().getBindingAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameWithBinding__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__QualifiedNameWithBinding__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getGroup_2()); }
+(rule__QualifiedNameWithBinding__Group_2__0)?
+{ after(grammarAccess.getQualifiedNameWithBindingAccess().getGroup_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__QualifiedNameWithBinding__Group_2__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__QualifiedNameWithBinding__Group_2__0__Impl
+	rule__QualifiedNameWithBinding__Group_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__Group_2__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getColonColonKeyword_2_0()); }
+
+	'::' 
+
+{ after(grammarAccess.getQualifiedNameWithBindingAccess().getColonColonKeyword_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameWithBinding__Group_2__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__QualifiedNameWithBinding__Group_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__Group_2__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingAssignment_2_1()); }
+(rule__QualifiedNameWithBinding__RemainingAssignment_2_1)
+{ after(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingAssignment_2_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Tuple__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Tuple__Group__0__Impl
+	rule__Tuple__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTupleAccess().getTupleAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTupleAccess().getTupleAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Tuple__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Tuple__Group__1__Impl
+	rule__Tuple__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTupleAccess().getLeftParenthesisKeyword_1()); }
+
+	'(' 
+
+{ after(grammarAccess.getTupleAccess().getLeftParenthesisKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Tuple__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Tuple__Group__2__Impl
+	rule__Tuple__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTupleAccess().getGroup_2()); }
+(rule__Tuple__Group_2__0)?
+{ after(grammarAccess.getTupleAccess().getGroup_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Tuple__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Tuple__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTupleAccess().getRightParenthesisKeyword_3()); }
+
+	')' 
+
+{ after(grammarAccess.getTupleAccess().getRightParenthesisKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__Tuple__Group_2__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Tuple__Group_2__0__Impl
+	rule__Tuple__Group_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group_2__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_0()); }
+(rule__Tuple__TupleElementsAssignment_2_0)
+{ after(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Tuple__Group_2__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Tuple__Group_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group_2__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTupleAccess().getGroup_2_1()); }
+(rule__Tuple__Group_2_1__0)*
+{ after(grammarAccess.getTupleAccess().getGroup_2_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Tuple__Group_2_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Tuple__Group_2_1__0__Impl
+	rule__Tuple__Group_2_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group_2_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTupleAccess().getCommaKeyword_2_1_0()); }
+
+	',' 
+
+{ after(grammarAccess.getTupleAccess().getCommaKeyword_2_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Tuple__Group_2_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Tuple__Group_2_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Tuple__Group_2_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_1_1()); }
+(rule__Tuple__TupleElementsAssignment_2_1_1)
+{ after(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ConditionalTestExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalTestExpression__Group__0__Impl
+	rule__ConditionalTestExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getExpAssignment_0()); }
+(rule__ConditionalTestExpression__ExpAssignment_0)
+{ after(grammarAccess.getConditionalTestExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalTestExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalTestExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getGroup_1()); }
+(rule__ConditionalTestExpression__Group_1__0)?
+{ after(grammarAccess.getConditionalTestExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ConditionalTestExpression__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalTestExpression__Group_1__0__Impl
+	rule__ConditionalTestExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getQuestionMarkKeyword_1_0()); }
+
+	'?' 
+
+{ after(grammarAccess.getConditionalTestExpressionAccess().getQuestionMarkKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalTestExpression__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalTestExpression__Group_1__1__Impl
+	rule__ConditionalTestExpression__Group_1__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueAssignment_1_1()); }
+(rule__ConditionalTestExpression__WhenTrueAssignment_1_1)
+{ after(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalTestExpression__Group_1__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalTestExpression__Group_1__2__Impl
+	rule__ConditionalTestExpression__Group_1__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__Group_1__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getColonKeyword_1_2()); }
+
+	':' 
+
+{ after(grammarAccess.getConditionalTestExpressionAccess().getColonKeyword_1_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalTestExpression__Group_1__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalTestExpression__Group_1__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__Group_1__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseAssignment_1_3()); }
+(rule__ConditionalTestExpression__WhenFalseAssignment_1_3)
+{ after(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseAssignment_1_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__ConditionalOrExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalOrExpression__Group__0__Impl
+	rule__ConditionalOrExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalOrExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_0()); }
+(rule__ConditionalOrExpression__ExpAssignment_0)
+{ after(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalOrExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalOrExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalOrExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getGroup_1()); }
+(rule__ConditionalOrExpression__Group_1__0)*
+{ after(grammarAccess.getConditionalOrExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ConditionalOrExpression__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalOrExpression__Group_1__0__Impl
+	rule__ConditionalOrExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalOrExpression__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getVerticalLineVerticalLineKeyword_1_0()); }
+
+	'||' 
+
+{ after(grammarAccess.getConditionalOrExpressionAccess().getVerticalLineVerticalLineKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalOrExpression__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalOrExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalOrExpression__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_1_1()); }
+(rule__ConditionalOrExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ConditionalAndExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalAndExpression__Group__0__Impl
+	rule__ConditionalAndExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalAndExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_0()); }
+(rule__ConditionalAndExpression__ExpAssignment_0)
+{ after(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalAndExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalAndExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalAndExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getGroup_1()); }
+(rule__ConditionalAndExpression__Group_1__0)*
+{ after(grammarAccess.getConditionalAndExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ConditionalAndExpression__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalAndExpression__Group_1__0__Impl
+	rule__ConditionalAndExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalAndExpression__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getAmpersandAmpersandKeyword_1_0()); }
+
+	'&&' 
+
+{ after(grammarAccess.getConditionalAndExpressionAccess().getAmpersandAmpersandKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ConditionalAndExpression__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConditionalAndExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalAndExpression__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_1_1()); }
+(rule__ConditionalAndExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__InclusiveOrExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InclusiveOrExpression__Group__0__Impl
+	rule__InclusiveOrExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InclusiveOrExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_0()); }
+(rule__InclusiveOrExpression__ExpAssignment_0)
+{ after(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InclusiveOrExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InclusiveOrExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InclusiveOrExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getGroup_1()); }
+(rule__InclusiveOrExpression__Group_1__0)*
+{ after(grammarAccess.getInclusiveOrExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__InclusiveOrExpression__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InclusiveOrExpression__Group_1__0__Impl
+	rule__InclusiveOrExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InclusiveOrExpression__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getVerticalLineKeyword_1_0()); }
+
+	'|' 
+
+{ after(grammarAccess.getInclusiveOrExpressionAccess().getVerticalLineKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InclusiveOrExpression__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InclusiveOrExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InclusiveOrExpression__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_1_1()); }
+(rule__InclusiveOrExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ExclusiveOrExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ExclusiveOrExpression__Group__0__Impl
+	rule__ExclusiveOrExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ExclusiveOrExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_0()); }
+(rule__ExclusiveOrExpression__ExpAssignment_0)
+{ after(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ExclusiveOrExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ExclusiveOrExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ExclusiveOrExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getGroup_1()); }
+(rule__ExclusiveOrExpression__Group_1__0)*
+{ after(grammarAccess.getExclusiveOrExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ExclusiveOrExpression__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ExclusiveOrExpression__Group_1__0__Impl
+	rule__ExclusiveOrExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ExclusiveOrExpression__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getCircumflexAccentKeyword_1_0()); }
+
+	'^' 
+
+{ after(grammarAccess.getExclusiveOrExpressionAccess().getCircumflexAccentKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ExclusiveOrExpression__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ExclusiveOrExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ExclusiveOrExpression__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_1_1()); }
+(rule__ExclusiveOrExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AndExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AndExpression__Group__0__Impl
+	rule__AndExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AndExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAndExpressionAccess().getExpAssignment_0()); }
+(rule__AndExpression__ExpAssignment_0)
+{ after(grammarAccess.getAndExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AndExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AndExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AndExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAndExpressionAccess().getGroup_1()); }
+(rule__AndExpression__Group_1__0)*
+{ after(grammarAccess.getAndExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AndExpression__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AndExpression__Group_1__0__Impl
+	rule__AndExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AndExpression__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAndExpressionAccess().getAmpersandKeyword_1_0()); }
+
+	'&' 
+
+{ after(grammarAccess.getAndExpressionAccess().getAmpersandKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AndExpression__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AndExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AndExpression__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAndExpressionAccess().getExpAssignment_1_1()); }
+(rule__AndExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getAndExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__EqualityExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__EqualityExpression__Group__0__Impl
+	rule__EqualityExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getExpAssignment_0()); }
+(rule__EqualityExpression__ExpAssignment_0)
+{ after(grammarAccess.getEqualityExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__EqualityExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__EqualityExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getGroup_1()); }
+(rule__EqualityExpression__Group_1__0)*
+{ after(grammarAccess.getEqualityExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__EqualityExpression__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__EqualityExpression__Group_1__0__Impl
+	rule__EqualityExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getOpAssignment_1_0()); }
+(rule__EqualityExpression__OpAssignment_1_0)
+{ after(grammarAccess.getEqualityExpressionAccess().getOpAssignment_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__EqualityExpression__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__EqualityExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getExpAssignment_1_1()); }
+(rule__EqualityExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getEqualityExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassificationExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassificationExpression__Group__0__Impl
+	rule__ClassificationExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getExpAssignment_0()); }
+(rule__ClassificationExpression__ExpAssignment_0)
+{ after(grammarAccess.getClassificationExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ClassificationExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassificationExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getGroup_1()); }
+(rule__ClassificationExpression__Group_1__0)?
+{ after(grammarAccess.getClassificationExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassificationExpression__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassificationExpression__Group_1__0__Impl
+	rule__ClassificationExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getOpAssignment_1_0()); }
+(rule__ClassificationExpression__OpAssignment_1_0)
+{ after(grammarAccess.getClassificationExpressionAccess().getOpAssignment_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ClassificationExpression__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassificationExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getTypeNameAssignment_1_1()); }
+(rule__ClassificationExpression__TypeNameAssignment_1_1)
+{ after(grammarAccess.getClassificationExpressionAccess().getTypeNameAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__RelationalExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__RelationalExpression__Group__0__Impl
+	rule__RelationalExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__RelationalExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getLeftAssignment_0()); }
+(rule__RelationalExpression__LeftAssignment_0)
+{ after(grammarAccess.getRelationalExpressionAccess().getLeftAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__RelationalExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__RelationalExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__RelationalExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); }
+(rule__RelationalExpression__Group_1__0)?
+{ after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__RelationalExpression__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__RelationalExpression__Group_1__0__Impl
+	rule__RelationalExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__RelationalExpression__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getOpAssignment_1_0()); }
+(rule__RelationalExpression__OpAssignment_1_0)
+{ after(grammarAccess.getRelationalExpressionAccess().getOpAssignment_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__RelationalExpression__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__RelationalExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__RelationalExpression__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_1()); }
+(rule__RelationalExpression__RightAssignment_1_1)
+{ after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ShiftExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ShiftExpression__Group__0__Impl
+	rule__ShiftExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getExpAssignment_0()); }
+(rule__ShiftExpression__ExpAssignment_0)
+{ after(grammarAccess.getShiftExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ShiftExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ShiftExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getGroup_1()); }
+(rule__ShiftExpression__Group_1__0)?
+{ after(grammarAccess.getShiftExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ShiftExpression__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ShiftExpression__Group_1__0__Impl
+	rule__ShiftExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getOpAssignment_1_0()); }
+(rule__ShiftExpression__OpAssignment_1_0)
+{ after(grammarAccess.getShiftExpressionAccess().getOpAssignment_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ShiftExpression__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ShiftExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getExpAssignment_1_1()); }
+(rule__ShiftExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getShiftExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AdditiveExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AdditiveExpression__Group__0__Impl
+	rule__AdditiveExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AdditiveExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_0()); }
+(rule__AdditiveExpression__ExpAssignment_0)
+{ after(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AdditiveExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AdditiveExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AdditiveExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); }
+(rule__AdditiveExpression__Group_1__0)*
+{ after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AdditiveExpression__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AdditiveExpression__Group_1__0__Impl
+	rule__AdditiveExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AdditiveExpression__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_0()); }
+(rule__AdditiveExpression__OpAssignment_1_0)
+{ after(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AdditiveExpression__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AdditiveExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AdditiveExpression__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_1_1()); }
+(rule__AdditiveExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__MultiplicativeExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__MultiplicativeExpression__Group__0__Impl
+	rule__MultiplicativeExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__MultiplicativeExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_0()); }
+(rule__MultiplicativeExpression__ExpAssignment_0)
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__MultiplicativeExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__MultiplicativeExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__MultiplicativeExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); }
+(rule__MultiplicativeExpression__Group_1__0)*
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__MultiplicativeExpression__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__MultiplicativeExpression__Group_1__0__Impl
+	rule__MultiplicativeExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__MultiplicativeExpression__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_0()); }
+(rule__MultiplicativeExpression__OpAssignment_1_0)
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__MultiplicativeExpression__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__MultiplicativeExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__MultiplicativeExpression__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_1_1()); }
+(rule__MultiplicativeExpression__ExpAssignment_1_1)
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__UnaryExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__UnaryExpression__Group__0__Impl
+	rule__UnaryExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__UnaryExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getUnaryExpressionAccess().getOpAssignment_0()); }
+(rule__UnaryExpression__OpAssignment_0)?
+{ after(grammarAccess.getUnaryExpressionAccess().getOpAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__UnaryExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__UnaryExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__UnaryExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getUnaryExpressionAccess().getExpAssignment_1()); }
+(rule__UnaryExpression__ExpAssignment_1)
+{ after(grammarAccess.getUnaryExpressionAccess().getExpAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__OperationCallExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__OperationCallExpression__Group__0__Impl
+	rule__OperationCallExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getFullStopKeyword_0()); }
+
+	'.' 
+
+{ after(grammarAccess.getOperationCallExpressionAccess().getFullStopKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__OperationCallExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__OperationCallExpression__Group__1__Impl
+	rule__OperationCallExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getOperationNameAssignment_1()); }
+(rule__OperationCallExpression__OperationNameAssignment_1)
+{ after(grammarAccess.getOperationCallExpressionAccess().getOperationNameAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__OperationCallExpression__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__OperationCallExpression__Group__2__Impl
+	rule__OperationCallExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getTupleAssignment_2()); }
+(rule__OperationCallExpression__TupleAssignment_2)
+{ after(grammarAccess.getOperationCallExpressionAccess().getTupleAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__OperationCallExpression__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__OperationCallExpression__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getSuffixAssignment_3()); }
+(rule__OperationCallExpression__SuffixAssignment_3)?
+{ after(grammarAccess.getOperationCallExpressionAccess().getSuffixAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__PropertyCallExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__PropertyCallExpression__Group__0__Impl
+	rule__PropertyCallExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getFullStopKeyword_0()); }
+
+	'.' 
+
+{ after(grammarAccess.getPropertyCallExpressionAccess().getFullStopKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__PropertyCallExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__PropertyCallExpression__Group__1__Impl
+	rule__PropertyCallExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameAssignment_1()); }
+(rule__PropertyCallExpression__PropertyNameAssignment_1)
+{ after(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__PropertyCallExpression__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__PropertyCallExpression__Group__2__Impl
+	rule__PropertyCallExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getGroup_2()); }
+(rule__PropertyCallExpression__Group_2__0)?
+{ after(grammarAccess.getPropertyCallExpressionAccess().getGroup_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__PropertyCallExpression__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__PropertyCallExpression__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getSuffixAssignment_3()); }
+(rule__PropertyCallExpression__SuffixAssignment_3)?
+{ after(grammarAccess.getPropertyCallExpressionAccess().getSuffixAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__PropertyCallExpression__Group_2__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__PropertyCallExpression__Group_2__0__Impl
+	rule__PropertyCallExpression__Group_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group_2__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getLeftSquareBracketKeyword_2_0()); }
+
+	'[' 
+
+{ after(grammarAccess.getPropertyCallExpressionAccess().getLeftSquareBracketKeyword_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__PropertyCallExpression__Group_2__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__PropertyCallExpression__Group_2__1__Impl
+	rule__PropertyCallExpression__Group_2__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group_2__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getIndexAssignment_2_1()); }
+(rule__PropertyCallExpression__IndexAssignment_2_1)
+{ after(grammarAccess.getPropertyCallExpressionAccess().getIndexAssignment_2_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__PropertyCallExpression__Group_2__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__PropertyCallExpression__Group_2__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__Group_2__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getRightSquareBracketKeyword_2_2()); }
+
+	']' 
+
+{ after(grammarAccess.getPropertyCallExpressionAccess().getRightSquareBracketKeyword_2_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__LinkOperationExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationExpression__Group__0__Impl
+	rule__LinkOperationExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationExpressionAccess().getFullStopKeyword_0()); }
+
+	'.' 
+
+{ after(grammarAccess.getLinkOperationExpressionAccess().getFullStopKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationExpression__Group__1__Impl
+	rule__LinkOperationExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationExpressionAccess().getKindAssignment_1()); }
+(rule__LinkOperationExpression__KindAssignment_1)
+{ after(grammarAccess.getLinkOperationExpressionAccess().getKindAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationExpression__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationExpression__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationExpression__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationExpressionAccess().getTupleAssignment_2()); }
+(rule__LinkOperationExpression__TupleAssignment_2)
+{ after(grammarAccess.getLinkOperationExpressionAccess().getTupleAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__LinkOperationTuple__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationTuple__Group__0__Impl
+	rule__LinkOperationTuple__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getLeftParenthesisKeyword_0()); }
+
+	'(' 
+
+{ after(grammarAccess.getLinkOperationTupleAccess().getLeftParenthesisKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTuple__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationTuple__Group__1__Impl
+	rule__LinkOperationTuple__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_1()); }
+(rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1)
+{ after(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTuple__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationTuple__Group__2__Impl
+	rule__LinkOperationTuple__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getGroup_2()); }
+(rule__LinkOperationTuple__Group_2__0)*
+{ after(grammarAccess.getLinkOperationTupleAccess().getGroup_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTuple__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationTuple__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getRightParenthesisKeyword_3()); }
+
+	')' 
+
+{ after(grammarAccess.getLinkOperationTupleAccess().getRightParenthesisKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__LinkOperationTuple__Group_2__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationTuple__Group_2__0__Impl
+	rule__LinkOperationTuple__Group_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__Group_2__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getCommaKeyword_2_0()); }
+
+	',' 
+
+{ after(grammarAccess.getLinkOperationTupleAccess().getCommaKeyword_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTuple__Group_2__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationTuple__Group_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__Group_2__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_2_1()); }
+(rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1)
+{ after(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_2_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__LinkOperationTupleElement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationTupleElement__Group__0__Impl
+	rule__LinkOperationTupleElement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getRoleAssignment_0()); }
+(rule__LinkOperationTupleElement__RoleAssignment_0)
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getRoleAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTupleElement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationTupleElement__Group__1__Impl
+	rule__LinkOperationTupleElement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getGroup_1()); }
+(rule__LinkOperationTupleElement__Group_1__0)?
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTupleElement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationTupleElement__Group__2__Impl
+	rule__LinkOperationTupleElement__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getEqualsSignGreaterThanSignKeyword_2()); }
+
+	'=>' 
+
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getEqualsSignGreaterThanSignKeyword_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTupleElement__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationTupleElement__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getObjectAssignment_3()); }
+(rule__LinkOperationTupleElement__ObjectAssignment_3)
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getObjectAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__LinkOperationTupleElement__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationTupleElement__Group_1__0__Impl
+	rule__LinkOperationTupleElement__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getLeftSquareBracketKeyword_1_0()); }
+
+	'[' 
+
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getLeftSquareBracketKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTupleElement__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationTupleElement__Group_1__1__Impl
+	rule__LinkOperationTupleElement__Group_1__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexAssignment_1_1()); }
+(rule__LinkOperationTupleElement__RoleIndexAssignment_1_1)
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LinkOperationTupleElement__Group_1__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LinkOperationTupleElement__Group_1__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__Group_1__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getRightSquareBracketKeyword_1_2()); }
+
+	']' 
+
+{ after(grammarAccess.getLinkOperationTupleElementAccess().getRightSquareBracketKeyword_1_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SequenceOperationExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceOperationExpression__Group__0__Impl
+	rule__SequenceOperationExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+
+	'->' 
+
+{ after(grammarAccess.getSequenceOperationExpressionAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequenceOperationExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceOperationExpression__Group__1__Impl
+	rule__SequenceOperationExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameAssignment_1()); }
+(rule__SequenceOperationExpression__OperationNameAssignment_1)
+{ after(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequenceOperationExpression__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceOperationExpression__Group__2__Impl
+	rule__SequenceOperationExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getTupleAssignment_2()); }
+(rule__SequenceOperationExpression__TupleAssignment_2)
+{ after(grammarAccess.getSequenceOperationExpressionAccess().getTupleAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequenceOperationExpression__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceOperationExpression__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getSuffixAssignment_3()); }
+(rule__SequenceOperationExpression__SuffixAssignment_3)?
+{ after(grammarAccess.getSequenceOperationExpressionAccess().getSuffixAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__SequenceReductionExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceReductionExpression__Group__0__Impl
+	rule__SequenceReductionExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+
+	'->' 
+
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequenceReductionExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceReductionExpression__Group__1__Impl
+	rule__SequenceReductionExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getReduceKeyword_1()); }
+
+	'reduce' 
+
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getReduceKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequenceReductionExpression__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceReductionExpression__Group__2__Impl
+	rule__SequenceReductionExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedAssignment_2()); }
+(rule__SequenceReductionExpression__IsOrderedAssignment_2)?
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequenceReductionExpression__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceReductionExpression__Group__3__Impl
+	rule__SequenceReductionExpression__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorAssignment_3()); }
+(rule__SequenceReductionExpression__BehaviorAssignment_3)
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequenceReductionExpression__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceReductionExpression__Group__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getSuffixAssignment_4()); }
+(rule__SequenceReductionExpression__SuffixAssignment_4)?
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getSuffixAssignment_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__SelectOrRejectOperation__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SelectOrRejectOperation__Group__0__Impl
+	rule__SelectOrRejectOperation__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+
+	'->' 
+
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SelectOrRejectOperation__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SelectOrRejectOperation__Group__1__Impl
+	rule__SelectOrRejectOperation__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getOpAssignment_1()); }
+(rule__SelectOrRejectOperation__OpAssignment_1)
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getOpAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SelectOrRejectOperation__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SelectOrRejectOperation__Group__2__Impl
+	rule__SelectOrRejectOperation__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getNameAssignment_2()); }
+(rule__SelectOrRejectOperation__NameAssignment_2)
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getNameAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SelectOrRejectOperation__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SelectOrRejectOperation__Group__3__Impl
+	rule__SelectOrRejectOperation__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getLeftParenthesisKeyword_3()); }
+
+	'(' 
+
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getLeftParenthesisKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SelectOrRejectOperation__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SelectOrRejectOperation__Group__4__Impl
+	rule__SelectOrRejectOperation__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getExprAssignment_4()); }
+(rule__SelectOrRejectOperation__ExprAssignment_4)
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getExprAssignment_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SelectOrRejectOperation__Group__5
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SelectOrRejectOperation__Group__5__Impl
+	rule__SelectOrRejectOperation__Group__6
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__5__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getRightParenthesisKeyword_5()); }
+
+	')' 
+
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getRightParenthesisKeyword_5()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SelectOrRejectOperation__Group__6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SelectOrRejectOperation__Group__6__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__Group__6__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getSuffixAssignment_6()); }
+(rule__SelectOrRejectOperation__SuffixAssignment_6)?
+{ after(grammarAccess.getSelectOrRejectOperationAccess().getSuffixAssignment_6()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__CollectOrIterateOperation__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__CollectOrIterateOperation__Group__0__Impl
+	rule__CollectOrIterateOperation__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+
+	'->' 
+
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__CollectOrIterateOperation__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__CollectOrIterateOperation__Group__1__Impl
+	rule__CollectOrIterateOperation__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getOpAssignment_1()); }
+(rule__CollectOrIterateOperation__OpAssignment_1)
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getOpAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__CollectOrIterateOperation__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__CollectOrIterateOperation__Group__2__Impl
+	rule__CollectOrIterateOperation__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getNameAssignment_2()); }
+(rule__CollectOrIterateOperation__NameAssignment_2)
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getNameAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__CollectOrIterateOperation__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__CollectOrIterateOperation__Group__3__Impl
+	rule__CollectOrIterateOperation__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getLeftParenthesisKeyword_3()); }
+
+	'(' 
+
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getLeftParenthesisKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__CollectOrIterateOperation__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__CollectOrIterateOperation__Group__4__Impl
+	rule__CollectOrIterateOperation__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getExprAssignment_4()); }
+(rule__CollectOrIterateOperation__ExprAssignment_4)
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getExprAssignment_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__CollectOrIterateOperation__Group__5
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__CollectOrIterateOperation__Group__5__Impl
+	rule__CollectOrIterateOperation__Group__6
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__5__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getRightParenthesisKeyword_5()); }
+
+	')' 
+
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getRightParenthesisKeyword_5()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__CollectOrIterateOperation__Group__6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__CollectOrIterateOperation__Group__6__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__Group__6__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getSuffixAssignment_6()); }
+(rule__CollectOrIterateOperation__SuffixAssignment_6)?
+{ after(grammarAccess.getCollectOrIterateOperationAccess().getSuffixAssignment_6()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__ForAllOrExistsOrOneOperation__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForAllOrExistsOrOneOperation__Group__0__Impl
+	rule__ForAllOrExistsOrOneOperation__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+
+	'->' 
+
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ForAllOrExistsOrOneOperation__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForAllOrExistsOrOneOperation__Group__1__Impl
+	rule__ForAllOrExistsOrOneOperation__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpAssignment_1()); }
+(rule__ForAllOrExistsOrOneOperation__OpAssignment_1)
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ForAllOrExistsOrOneOperation__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForAllOrExistsOrOneOperation__Group__2__Impl
+	rule__ForAllOrExistsOrOneOperation__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameAssignment_2()); }
+(rule__ForAllOrExistsOrOneOperation__NameAssignment_2)
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ForAllOrExistsOrOneOperation__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForAllOrExistsOrOneOperation__Group__3__Impl
+	rule__ForAllOrExistsOrOneOperation__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getLeftParenthesisKeyword_3()); }
+
+	'(' 
+
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getLeftParenthesisKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ForAllOrExistsOrOneOperation__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForAllOrExistsOrOneOperation__Group__4__Impl
+	rule__ForAllOrExistsOrOneOperation__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprAssignment_4()); }
+(rule__ForAllOrExistsOrOneOperation__ExprAssignment_4)
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprAssignment_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ForAllOrExistsOrOneOperation__Group__5
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForAllOrExistsOrOneOperation__Group__5__Impl
+	rule__ForAllOrExistsOrOneOperation__Group__6
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__5__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getRightParenthesisKeyword_5()); }
+
+	')' 
+
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getRightParenthesisKeyword_5()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ForAllOrExistsOrOneOperation__Group__6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForAllOrExistsOrOneOperation__Group__6__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__Group__6__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixAssignment_6()); }
+(rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6)?
+{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixAssignment_6()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__IsUniqueOperation__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__IsUniqueOperation__Group__0__Impl
+	rule__IsUniqueOperation__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+
+	'->' 
+
+{ after(grammarAccess.getIsUniqueOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__IsUniqueOperation__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__IsUniqueOperation__Group__1__Impl
+	rule__IsUniqueOperation__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getIsUniqueKeyword_1()); }
+
+	'isUnique' 
+
+{ after(grammarAccess.getIsUniqueOperationAccess().getIsUniqueKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__IsUniqueOperation__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__IsUniqueOperation__Group__2__Impl
+	rule__IsUniqueOperation__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getNameAssignment_2()); }
+(rule__IsUniqueOperation__NameAssignment_2)
+{ after(grammarAccess.getIsUniqueOperationAccess().getNameAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__IsUniqueOperation__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__IsUniqueOperation__Group__3__Impl
+	rule__IsUniqueOperation__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getLeftParenthesisKeyword_3()); }
+
+	'(' 
+
+{ after(grammarAccess.getIsUniqueOperationAccess().getLeftParenthesisKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__IsUniqueOperation__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__IsUniqueOperation__Group__4__Impl
+	rule__IsUniqueOperation__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getExprAssignment_4()); }
+(rule__IsUniqueOperation__ExprAssignment_4)
+{ after(grammarAccess.getIsUniqueOperationAccess().getExprAssignment_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__IsUniqueOperation__Group__5
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__IsUniqueOperation__Group__5__Impl
+	rule__IsUniqueOperation__Group__6
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__5__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getRightParenthesisKeyword_5()); }
+
+	')' 
+
+{ after(grammarAccess.getIsUniqueOperationAccess().getRightParenthesisKeyword_5()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__IsUniqueOperation__Group__6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__IsUniqueOperation__Group__6__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__Group__6__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getSuffixAssignment_6()); }
+(rule__IsUniqueOperation__SuffixAssignment_6)?
+{ after(grammarAccess.getIsUniqueOperationAccess().getSuffixAssignment_6()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__ParenthesizedExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ParenthesizedExpression__Group__0__Impl
+	rule__ParenthesizedExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); }
+
+	'(' 
+
+{ after(grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ParenthesizedExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ParenthesizedExpression__Group__1__Impl
+	rule__ParenthesizedExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastAssignment_1()); }
+(rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1)
+{ after(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ParenthesizedExpression__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ParenthesizedExpression__Group__2__Impl
+	rule__ParenthesizedExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); }
+
+	')' 
+
+{ after(grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ParenthesizedExpression__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ParenthesizedExpression__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getAlternatives_3()); }
+(rule__ParenthesizedExpression__Alternatives_3)?
+{ after(grammarAccess.getParenthesizedExpressionAccess().getAlternatives_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__NullExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NullExpression__Group__0__Impl
+	rule__NullExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NullExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNullExpressionAccess().getNullExpressionAction_0()); }
+(
+
+)
+{ after(grammarAccess.getNullExpressionAccess().getNullExpressionAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__NullExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NullExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NullExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNullExpressionAccess().getNullKeyword_1()); }
+
+	'null' 
+
+{ after(grammarAccess.getNullExpressionAccess().getNullKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ThisExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ThisExpression__Group__0__Impl
+	rule__ThisExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ThisExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getThisExpressionAccess().getThisExpressionAction_0()); }
+(
+
+)
+{ after(grammarAccess.getThisExpressionAccess().getThisExpressionAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ThisExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ThisExpression__Group__1__Impl
+	rule__ThisExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ThisExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getThisExpressionAccess().getThisKeyword_1()); }
+
+	'this' 
+
+{ after(grammarAccess.getThisExpressionAccess().getThisKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ThisExpression__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ThisExpression__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ThisExpression__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getThisExpressionAccess().getSuffixAssignment_2()); }
+(rule__ThisExpression__SuffixAssignment_2)?
+{ after(grammarAccess.getThisExpressionAccess().getSuffixAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SuperInvocationExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SuperInvocationExpression__Group__0__Impl
+	rule__SuperInvocationExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getSuperKeyword_0()); }
+
+	'super' 
+
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getSuperKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SuperInvocationExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SuperInvocationExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getAlternatives_1()); }
+(rule__SuperInvocationExpression__Alternatives_1)
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__SuperInvocationExpression__Group_1_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SuperInvocationExpression__Group_1_1__0__Impl
+	rule__SuperInvocationExpression__Group_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__Group_1_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getFullStopKeyword_1_1_0()); }
+
+	'.' 
+
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getFullStopKeyword_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SuperInvocationExpression__Group_1_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SuperInvocationExpression__Group_1_1__1__Impl
+	rule__SuperInvocationExpression__Group_1_1__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__Group_1_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameAssignment_1_1_1()); }
+(rule__SuperInvocationExpression__OperationNameAssignment_1_1_1)
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameAssignment_1_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SuperInvocationExpression__Group_1_1__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SuperInvocationExpression__Group_1_1__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__Group_1_1__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_1_2()); }
+(rule__SuperInvocationExpression__TupleAssignment_1_1_2)
+{ after(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_1_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__InstanceCreationExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationExpression__Group__0__Impl
+	rule__InstanceCreationExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getNewKeyword_0()); }
+
+	'new' 
+
+{ after(grammarAccess.getInstanceCreationExpressionAccess().getNewKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationExpression__Group__1__Impl
+	rule__InstanceCreationExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getConstructorAssignment_1()); }
+(rule__InstanceCreationExpression__ConstructorAssignment_1)
+{ after(grammarAccess.getInstanceCreationExpressionAccess().getConstructorAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationExpression__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationExpression__Group__2__Impl
+	rule__InstanceCreationExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getTupleAssignment_2()); }
+(rule__InstanceCreationExpression__TupleAssignment_2)
+{ after(grammarAccess.getInstanceCreationExpressionAccess().getTupleAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationExpression__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationExpression__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getSuffixAssignment_3()); }
+(rule__InstanceCreationExpression__SuffixAssignment_3)?
+{ after(grammarAccess.getInstanceCreationExpressionAccess().getSuffixAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__InstanceCreationTuple__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationTuple__Group__0__Impl
+	rule__InstanceCreationTuple__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleAction_0()); }
+(
+
+)
+{ after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTuple__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationTuple__Group__1__Impl
+	rule__InstanceCreationTuple__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getLeftParenthesisKeyword_1()); }
+
+	'(' 
+
+{ after(grammarAccess.getInstanceCreationTupleAccess().getLeftParenthesisKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTuple__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationTuple__Group__2__Impl
+	rule__InstanceCreationTuple__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getGroup_2()); }
+(rule__InstanceCreationTuple__Group_2__0)?
+{ after(grammarAccess.getInstanceCreationTupleAccess().getGroup_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTuple__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationTuple__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getRightParenthesisKeyword_3()); }
+
+	')' 
+
+{ after(grammarAccess.getInstanceCreationTupleAccess().getRightParenthesisKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__InstanceCreationTuple__Group_2__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationTuple__Group_2__0__Impl
+	rule__InstanceCreationTuple__Group_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group_2__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_0()); }
+(rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0)
+{ after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTuple__Group_2__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationTuple__Group_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group_2__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getGroup_2_1()); }
+(rule__InstanceCreationTuple__Group_2_1__0)*
+{ after(grammarAccess.getInstanceCreationTupleAccess().getGroup_2_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__InstanceCreationTuple__Group_2_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationTuple__Group_2_1__0__Impl
+	rule__InstanceCreationTuple__Group_2_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group_2_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getCommaKeyword_2_1_0()); }
+
+	',' 
+
+{ after(grammarAccess.getInstanceCreationTupleAccess().getCommaKeyword_2_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTuple__Group_2_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationTuple__Group_2_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__Group_2_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_1_1()); }
+(rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1)
+{ after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__InstanceCreationTupleElement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationTupleElement__Group__0__Impl
+	rule__InstanceCreationTupleElement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTupleElement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleElementAccess().getRoleAssignment_0()); }
+(rule__InstanceCreationTupleElement__RoleAssignment_0)
+{ after(grammarAccess.getInstanceCreationTupleElementAccess().getRoleAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTupleElement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationTupleElement__Group__1__Impl
+	rule__InstanceCreationTupleElement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTupleElement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleElementAccess().getEqualsSignGreaterThanSignKeyword_1()); }
+
+	'=>' 
+
+{ after(grammarAccess.getInstanceCreationTupleElementAccess().getEqualsSignGreaterThanSignKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationTupleElement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationTupleElement__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTupleElement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleElementAccess().getObjectAssignment_2()); }
+(rule__InstanceCreationTupleElement__ObjectAssignment_2)
+{ after(grammarAccess.getInstanceCreationTupleElementAccess().getObjectAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SequenceConstructionOrAccessCompletion__Group_0__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl
+	rule__SequenceConstructionOrAccessCompletion__Group_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorAssignment_0_0()); }
+(rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorAssignment_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequenceConstructionOrAccessCompletion__Group_0__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives_0_1()); }
+(rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1)
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AccessCompletion__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AccessCompletion__Group__0__Impl
+	rule__AccessCompletion__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AccessCompletion__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAccessCompletionAccess().getAccessIndexAssignment_0()); }
+(rule__AccessCompletion__AccessIndexAssignment_0)
+{ after(grammarAccess.getAccessCompletionAccess().getAccessIndexAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AccessCompletion__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AccessCompletion__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AccessCompletion__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAccessCompletionAccess().getRightSquareBracketKeyword_1()); }
+
+	']' 
+
+{ after(grammarAccess.getAccessCompletionAccess().getRightSquareBracketKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__PartialSequenceConstructionCompletion__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__PartialSequenceConstructionCompletion__Group__0__Impl
+	rule__PartialSequenceConstructionCompletion__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PartialSequenceConstructionCompletion__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPartialSequenceConstructionCompletionAccess().getRightSquareBracketKeyword_0()); }
+
+	']' 
+
+{ after(grammarAccess.getPartialSequenceConstructionCompletionAccess().getRightSquareBracketKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__PartialSequenceConstructionCompletion__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__PartialSequenceConstructionCompletion__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PartialSequenceConstructionCompletion__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionAssignment_1()); }
+(rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1)
+{ after(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__SequenceConstructionExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceConstructionExpression__Group__0__Impl
+	rule__SequenceConstructionExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getLeftCurlyBracketKeyword_0()); }
+
+	'{' 
+
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getLeftCurlyBracketKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequenceConstructionExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceConstructionExpression__Group__1__Impl
+	rule__SequenceConstructionExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_1()); }
+(rule__SequenceConstructionExpression__SequenceElementAssignment_1)
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequenceConstructionExpression__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceConstructionExpression__Group__2__Impl
+	rule__SequenceConstructionExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getAlternatives_2()); }
+(rule__SequenceConstructionExpression__Alternatives_2)
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getAlternatives_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequenceConstructionExpression__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceConstructionExpression__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getRightCurlyBracketKeyword_3()); }
+
+	'}' 
+
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getRightCurlyBracketKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__SequenceConstructionExpression__Group_2_0__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceConstructionExpression__Group_2_0__0__Impl
+	rule__SequenceConstructionExpression__Group_2_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group_2_0__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getCommaKeyword_2_0_0()); }
+
+	',' 
+
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getCommaKeyword_2_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequenceConstructionExpression__Group_2_0__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceConstructionExpression__Group_2_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group_2_0__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_2_0_1()); }
+(rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1)
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_2_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__SequenceConstructionExpression__Group_2_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceConstructionExpression__Group_2_1__0__Impl
+	rule__SequenceConstructionExpression__Group_2_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group_2_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getFullStopFullStopKeyword_2_1_0()); }
+
+	'..' 
+
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getFullStopFullStopKeyword_2_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequenceConstructionExpression__Group_2_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequenceConstructionExpression__Group_2_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__Group_2_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperAssignment_2_1_1()); }
+(rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1)
+{ after(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperAssignment_2_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassExtentExpression__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassExtentExpression__Group__0__Impl
+	rule__ClassExtentExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassExtentExpression__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassExtentExpressionAccess().getClassExtentExpressionAction_0()); }
+(
+
+)
+{ after(grammarAccess.getClassExtentExpressionAccess().getClassExtentExpressionAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ClassExtentExpression__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassExtentExpression__Group__1__Impl
+	rule__ClassExtentExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassExtentExpression__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassExtentExpressionAccess().getFullStopKeyword_1()); }
+
+	'.' 
+
+{ after(grammarAccess.getClassExtentExpressionAccess().getFullStopKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ClassExtentExpression__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassExtentExpression__Group__2__Impl
+	rule__ClassExtentExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassExtentExpression__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassExtentExpressionAccess().getAllInstancesKeyword_2()); }
+
+	'allInstances' 
+
+{ after(grammarAccess.getClassExtentExpressionAccess().getAllInstancesKeyword_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ClassExtentExpression__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassExtentExpression__Group__3__Impl
+	rule__ClassExtentExpression__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassExtentExpression__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassExtentExpressionAccess().getLeftParenthesisKeyword_3()); }
+
+	'(' 
+
+{ after(grammarAccess.getClassExtentExpressionAccess().getLeftParenthesisKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ClassExtentExpression__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassExtentExpression__Group__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassExtentExpression__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassExtentExpressionAccess().getRightParenthesisKeyword_4()); }
+
+	')' 
+
+{ after(grammarAccess.getClassExtentExpressionAccess().getRightParenthesisKeyword_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__Block__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Block__Group__0__Impl
+	rule__Block__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Block__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getBlockAccess().getLeftCurlyBracketKeyword_0()); }
+
+	'{' 
+
+{ after(grammarAccess.getBlockAccess().getLeftCurlyBracketKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Block__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Block__Group__1__Impl
+	rule__Block__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Block__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getBlockAccess().getBlockAction_1()); }
+(
+
+)
+{ after(grammarAccess.getBlockAccess().getBlockAction_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Block__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Block__Group__2__Impl
+	rule__Block__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Block__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getBlockAccess().getSequenceAssignment_2()); }
+(rule__Block__SequenceAssignment_2)?
+{ after(grammarAccess.getBlockAccess().getSequenceAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Block__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Block__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Block__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getBlockAccess().getRightCurlyBracketKeyword_3()); }
+
+	'}' 
+
+{ after(grammarAccess.getBlockAccess().getRightCurlyBracketKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__DocumentedStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__DocumentedStatement__Group__0__Impl
+	rule__DocumentedStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DocumentedStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDocumentedStatementAccess().getCommentAssignment_0()); }
+(rule__DocumentedStatement__CommentAssignment_0)?
+{ after(grammarAccess.getDocumentedStatementAccess().getCommentAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__DocumentedStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__DocumentedStatement__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DocumentedStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDocumentedStatementAccess().getStatementAssignment_1()); }
+(rule__DocumentedStatement__StatementAssignment_1)
+{ after(grammarAccess.getDocumentedStatementAccess().getStatementAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__InlineStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InlineStatement__Group__0__Impl
+	rule__InlineStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getSolidusAsteriskCommercialAtKeyword_0()); }
+
+	'/*@' 
+
+{ after(grammarAccess.getInlineStatementAccess().getSolidusAsteriskCommercialAtKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InlineStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InlineStatement__Group__1__Impl
+	rule__InlineStatement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getInlineKeyword_1()); }
+
+	'inline' 
+
+{ after(grammarAccess.getInlineStatementAccess().getInlineKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InlineStatement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InlineStatement__Group__2__Impl
+	rule__InlineStatement__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getLeftParenthesisKeyword_2()); }
+
+	'(' 
+
+{ after(grammarAccess.getInlineStatementAccess().getLeftParenthesisKeyword_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InlineStatement__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InlineStatement__Group__3__Impl
+	rule__InlineStatement__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getLangageNameAssignment_3()); }
+(rule__InlineStatement__LangageNameAssignment_3)
+{ after(grammarAccess.getInlineStatementAccess().getLangageNameAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InlineStatement__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InlineStatement__Group__4__Impl
+	rule__InlineStatement__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getRightParenthesisKeyword_4()); }
+
+	')' 
+
+{ after(grammarAccess.getInlineStatementAccess().getRightParenthesisKeyword_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InlineStatement__Group__5
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InlineStatement__Group__5__Impl
+	rule__InlineStatement__Group__6
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__5__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getBodyAssignment_5()); }
+(rule__InlineStatement__BodyAssignment_5)
+{ after(grammarAccess.getInlineStatementAccess().getBodyAssignment_5()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InlineStatement__Group__6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InlineStatement__Group__6__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__Group__6__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getAsteriskSolidusKeyword_6()); }
+
+	'*/' 
+
+{ after(grammarAccess.getInlineStatementAccess().getAsteriskSolidusKeyword_6()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__AnnotatedStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AnnotatedStatement__Group__0__Impl
+	rule__AnnotatedStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AnnotatedStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotatedStatementAccess().getSolidusSolidusCommercialAtKeyword_0()); }
+
+	'//@' 
+
+{ after(grammarAccess.getAnnotatedStatementAccess().getSolidusSolidusCommercialAtKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AnnotatedStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AnnotatedStatement__Group__1__Impl
+	rule__AnnotatedStatement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AnnotatedStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotatedStatementAccess().getAnnotationAssignment_1()); }
+(rule__AnnotatedStatement__AnnotationAssignment_1)
+{ after(grammarAccess.getAnnotatedStatementAccess().getAnnotationAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AnnotatedStatement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AnnotatedStatement__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AnnotatedStatement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotatedStatementAccess().getStatementAssignment_2()); }
+(rule__AnnotatedStatement__StatementAssignment_2)
+{ after(grammarAccess.getAnnotatedStatementAccess().getStatementAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__Annotation__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Annotation__Group__0__Impl
+	rule__Annotation__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getKindAssignment_0()); }
+(rule__Annotation__KindAssignment_0)
+{ after(grammarAccess.getAnnotationAccess().getKindAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Annotation__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Annotation__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getGroup_1()); }
+(rule__Annotation__Group_1__0)?
+{ after(grammarAccess.getAnnotationAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__Annotation__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Annotation__Group_1__0__Impl
+	rule__Annotation__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getLeftParenthesisKeyword_1_0()); }
+
+	'(' 
+
+{ after(grammarAccess.getAnnotationAccess().getLeftParenthesisKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Annotation__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Annotation__Group_1__1__Impl
+	rule__Annotation__Group_1__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getArgsAssignment_1_1()); }
+(rule__Annotation__ArgsAssignment_1_1)
+{ after(grammarAccess.getAnnotationAccess().getArgsAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Annotation__Group_1__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Annotation__Group_1__2__Impl
+	rule__Annotation__Group_1__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group_1__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getGroup_1_2()); }
+(rule__Annotation__Group_1_2__0)*
+{ after(grammarAccess.getAnnotationAccess().getGroup_1_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Annotation__Group_1__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Annotation__Group_1__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group_1__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getRightParenthesisKeyword_1_3()); }
+
+	')' 
+
+{ after(grammarAccess.getAnnotationAccess().getRightParenthesisKeyword_1_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__Annotation__Group_1_2__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Annotation__Group_1_2__0__Impl
+	rule__Annotation__Group_1_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group_1_2__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getCommaKeyword_1_2_0()); }
+
+	',' 
+
+{ after(grammarAccess.getAnnotationAccess().getCommaKeyword_1_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Annotation__Group_1_2__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Annotation__Group_1_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Annotation__Group_1_2__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getArgsAssignment_1_2_1()); }
+(rule__Annotation__ArgsAssignment_1_2_1)
+{ after(grammarAccess.getAnnotationAccess().getArgsAssignment_1_2_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__EmptyStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__EmptyStatement__Group__0__Impl
+	rule__EmptyStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__EmptyStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getEmptyStatementAccess().getEmptyStatementAction_0()); }
+(
+
+)
+{ after(grammarAccess.getEmptyStatementAccess().getEmptyStatementAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__EmptyStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__EmptyStatement__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__EmptyStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getEmptyStatementAccess().getSemicolonKeyword_1()); }
+
+	';' 
+
+{ after(grammarAccess.getEmptyStatementAccess().getSemicolonKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__LocalNameDeclarationStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LocalNameDeclarationStatement__Group__0__Impl
+	rule__LocalNameDeclarationStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getLetKeyword_0()); }
+
+	'let' 
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getLetKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LocalNameDeclarationStatement__Group__1__Impl
+	rule__LocalNameDeclarationStatement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameAssignment_1()); }
+(rule__LocalNameDeclarationStatement__VarNameAssignment_1)
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LocalNameDeclarationStatement__Group__2__Impl
+	rule__LocalNameDeclarationStatement__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getColonKeyword_2()); }
+
+	':' 
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getColonKeyword_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LocalNameDeclarationStatement__Group__3__Impl
+	rule__LocalNameDeclarationStatement__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeAssignment_3()); }
+(rule__LocalNameDeclarationStatement__TypeAssignment_3)
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LocalNameDeclarationStatement__Group__4__Impl
+	rule__LocalNameDeclarationStatement__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup_4()); }
+(rule__LocalNameDeclarationStatement__Group_4__0)?
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__5
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LocalNameDeclarationStatement__Group__5__Impl
+	rule__LocalNameDeclarationStatement__Group__6
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__5__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getEqualsSignKeyword_5()); }
+
+	'=' 
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getEqualsSignKeyword_5()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LocalNameDeclarationStatement__Group__6__Impl
+	rule__LocalNameDeclarationStatement__Group__7
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__6__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getInitAssignment_6()); }
+(rule__LocalNameDeclarationStatement__InitAssignment_6)
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getInitAssignment_6()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group__7
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LocalNameDeclarationStatement__Group__7__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group__7__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getSemicolonKeyword_7()); }
+
+	';' 
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getSemicolonKeyword_7()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__LocalNameDeclarationStatement__Group_4__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LocalNameDeclarationStatement__Group_4__0__Impl
+	rule__LocalNameDeclarationStatement__Group_4__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group_4__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorAssignment_4_0()); }
+(rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0)
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorAssignment_4_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LocalNameDeclarationStatement__Group_4__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LocalNameDeclarationStatement__Group_4__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__Group_4__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getRightSquareBracketKeyword_4_1()); }
+
+	']' 
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getRightSquareBracketKeyword_4_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__IfStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__IfStatement__Group__0__Impl
+	rule__IfStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IfStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIfStatementAccess().getIfKeyword_0()); }
+
+	'if' 
+
+{ after(grammarAccess.getIfStatementAccess().getIfKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__IfStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__IfStatement__Group__1__Impl
+	rule__IfStatement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IfStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIfStatementAccess().getSequentialClaussesAssignment_1()); }
+(rule__IfStatement__SequentialClaussesAssignment_1)
+{ after(grammarAccess.getIfStatementAccess().getSequentialClaussesAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__IfStatement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__IfStatement__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IfStatement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIfStatementAccess().getFinalClauseAssignment_2()); }
+(rule__IfStatement__FinalClauseAssignment_2)?
+{ after(grammarAccess.getIfStatementAccess().getFinalClauseAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SequentialClauses__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequentialClauses__Group__0__Impl
+	rule__SequentialClauses__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_0()); }
+(rule__SequentialClauses__ConccurentClausesAssignment_0)
+{ after(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequentialClauses__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequentialClauses__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getGroup_1()); }
+(rule__SequentialClauses__Group_1__0)*
+{ after(grammarAccess.getSequentialClausesAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__SequentialClauses__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequentialClauses__Group_1__0__Impl
+	rule__SequentialClauses__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getElseKeyword_1_0()); }
+
+	'else' 
+
+{ after(grammarAccess.getSequentialClausesAccess().getElseKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequentialClauses__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequentialClauses__Group_1__1__Impl
+	rule__SequentialClauses__Group_1__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getIfKeyword_1_1()); }
+
+	'if' 
+
+{ after(grammarAccess.getSequentialClausesAccess().getIfKeyword_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SequentialClauses__Group_1__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SequentialClauses__Group_1__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__Group_1__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_1_2()); }
+(rule__SequentialClauses__ConccurentClausesAssignment_1_2)
+{ after(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_1_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ConcurrentClauses__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConcurrentClauses__Group__0__Impl
+	rule__ConcurrentClauses__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_0()); }
+(rule__ConcurrentClauses__NonFinalClauseAssignment_0)
+{ after(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ConcurrentClauses__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConcurrentClauses__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getGroup_1()); }
+(rule__ConcurrentClauses__Group_1__0)*
+{ after(grammarAccess.getConcurrentClausesAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ConcurrentClauses__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConcurrentClauses__Group_1__0__Impl
+	rule__ConcurrentClauses__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getOrKeyword_1_0()); }
+
+	'or' 
+
+{ after(grammarAccess.getConcurrentClausesAccess().getOrKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ConcurrentClauses__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConcurrentClauses__Group_1__1__Impl
+	rule__ConcurrentClauses__Group_1__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getIfKeyword_1_1()); }
+
+	'if' 
+
+{ after(grammarAccess.getConcurrentClausesAccess().getIfKeyword_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ConcurrentClauses__Group_1__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ConcurrentClauses__Group_1__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__Group_1__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_1_2()); }
+(rule__ConcurrentClauses__NonFinalClauseAssignment_1_2)
+{ after(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_1_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__NonFinalClause__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NonFinalClause__Group__0__Impl
+	rule__NonFinalClause__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NonFinalClause__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getLeftParenthesisKeyword_0()); }
+
+	'(' 
+
+{ after(grammarAccess.getNonFinalClauseAccess().getLeftParenthesisKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__NonFinalClause__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NonFinalClause__Group__1__Impl
+	rule__NonFinalClause__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NonFinalClause__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getConditionAssignment_1()); }
+(rule__NonFinalClause__ConditionAssignment_1)
+{ after(grammarAccess.getNonFinalClauseAccess().getConditionAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__NonFinalClause__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NonFinalClause__Group__2__Impl
+	rule__NonFinalClause__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NonFinalClause__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getRightParenthesisKeyword_2()); }
+
+	')' 
+
+{ after(grammarAccess.getNonFinalClauseAccess().getRightParenthesisKeyword_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__NonFinalClause__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__NonFinalClause__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NonFinalClause__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getBlockAssignment_3()); }
+(rule__NonFinalClause__BlockAssignment_3)
+{ after(grammarAccess.getNonFinalClauseAccess().getBlockAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__FinalClause__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__FinalClause__Group__0__Impl
+	rule__FinalClause__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__FinalClause__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getFinalClauseAccess().getElseKeyword_0()); }
+
+	'else' 
+
+{ after(grammarAccess.getFinalClauseAccess().getElseKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__FinalClause__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__FinalClause__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__FinalClause__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getFinalClauseAccess().getBlockAssignment_1()); }
+(rule__FinalClause__BlockAssignment_1)
+{ after(grammarAccess.getFinalClauseAccess().getBlockAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__SwitchStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchStatement__Group__0__Impl
+	rule__SwitchStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getSwitchKeyword_0()); }
+
+	'switch' 
+
+{ after(grammarAccess.getSwitchStatementAccess().getSwitchKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchStatement__Group__1__Impl
+	rule__SwitchStatement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getLeftParenthesisKeyword_1()); }
+
+	'(' 
+
+{ after(grammarAccess.getSwitchStatementAccess().getLeftParenthesisKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchStatement__Group__2__Impl
+	rule__SwitchStatement__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getExpressionAssignment_2()); }
+(rule__SwitchStatement__ExpressionAssignment_2)
+{ after(grammarAccess.getSwitchStatementAccess().getExpressionAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchStatement__Group__3__Impl
+	rule__SwitchStatement__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getRightParenthesisKeyword_3()); }
+
+	')' 
+
+{ after(grammarAccess.getSwitchStatementAccess().getRightParenthesisKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchStatement__Group__4__Impl
+	rule__SwitchStatement__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getLeftCurlyBracketKeyword_4()); }
+
+	'{' 
+
+{ after(grammarAccess.getSwitchStatementAccess().getLeftCurlyBracketKeyword_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__5
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchStatement__Group__5__Impl
+	rule__SwitchStatement__Group__6
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__5__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getSwitchClauseAssignment_5()); }
+(rule__SwitchStatement__SwitchClauseAssignment_5)*
+{ after(grammarAccess.getSwitchStatementAccess().getSwitchClauseAssignment_5()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchStatement__Group__6__Impl
+	rule__SwitchStatement__Group__7
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__6__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getDefaultClauseAssignment_6()); }
+(rule__SwitchStatement__DefaultClauseAssignment_6)?
+{ after(grammarAccess.getSwitchStatementAccess().getDefaultClauseAssignment_6()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SwitchStatement__Group__7
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchStatement__Group__7__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__Group__7__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getRightCurlyBracketKeyword_7()); }
+
+	'}' 
+
+{ after(grammarAccess.getSwitchStatementAccess().getRightCurlyBracketKeyword_7()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__SwitchClause__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchClause__Group__0__Impl
+	rule__SwitchClause__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchClause__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_0()); }
+(rule__SwitchClause__SwitchCaseAssignment_0)
+{ after(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SwitchClause__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchClause__Group__1__Impl
+	rule__SwitchClause__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchClause__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_1()); }
+(rule__SwitchClause__SwitchCaseAssignment_1)*
+{ after(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SwitchClause__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchClause__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchClause__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchClauseAccess().getStatementSequenceAssignment_2()); }
+(rule__SwitchClause__StatementSequenceAssignment_2)
+{ after(grammarAccess.getSwitchClauseAccess().getStatementSequenceAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SwitchCase__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchCase__Group__0__Impl
+	rule__SwitchCase__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchCase__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchCaseAccess().getCaseKeyword_0()); }
+
+	'case' 
+
+{ after(grammarAccess.getSwitchCaseAccess().getCaseKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SwitchCase__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchCase__Group__1__Impl
+	rule__SwitchCase__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchCase__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchCaseAccess().getExpressionAssignment_1()); }
+(rule__SwitchCase__ExpressionAssignment_1)
+{ after(grammarAccess.getSwitchCaseAccess().getExpressionAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SwitchCase__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchCase__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchCase__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchCaseAccess().getColonKeyword_2()); }
+
+	':' 
+
+{ after(grammarAccess.getSwitchCaseAccess().getColonKeyword_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SwitchDefaultClause__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchDefaultClause__Group__0__Impl
+	rule__SwitchDefaultClause__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchDefaultClause__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchDefaultClauseAccess().getDefaultKeyword_0()); }
+
+	'default' 
+
+{ after(grammarAccess.getSwitchDefaultClauseAccess().getDefaultKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SwitchDefaultClause__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchDefaultClause__Group__1__Impl
+	rule__SwitchDefaultClause__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchDefaultClause__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchDefaultClauseAccess().getColonKeyword_1()); }
+
+	':' 
+
+{ after(grammarAccess.getSwitchDefaultClauseAccess().getColonKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SwitchDefaultClause__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SwitchDefaultClause__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchDefaultClause__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceAssignment_2()); }
+(rule__SwitchDefaultClause__StatementSequenceAssignment_2)
+{ after(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__WhileStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__WhileStatement__Group__0__Impl
+	rule__WhileStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getWhileKeyword_0()); }
+
+	'while' 
+
+{ after(grammarAccess.getWhileStatementAccess().getWhileKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__WhileStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__WhileStatement__Group__1__Impl
+	rule__WhileStatement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getLeftParenthesisKeyword_1()); }
+
+	'(' 
+
+{ after(grammarAccess.getWhileStatementAccess().getLeftParenthesisKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__WhileStatement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__WhileStatement__Group__2__Impl
+	rule__WhileStatement__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getConditionAssignment_2()); }
+(rule__WhileStatement__ConditionAssignment_2)
+{ after(grammarAccess.getWhileStatementAccess().getConditionAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__WhileStatement__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__WhileStatement__Group__3__Impl
+	rule__WhileStatement__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getRightParenthesisKeyword_3()); }
+
+	')' 
+
+{ after(grammarAccess.getWhileStatementAccess().getRightParenthesisKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__WhileStatement__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__WhileStatement__Group__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getBlockAssignment_4()); }
+(rule__WhileStatement__BlockAssignment_4)
+{ after(grammarAccess.getWhileStatementAccess().getBlockAssignment_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__DoStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__DoStatement__Group__0__Impl
+	rule__DoStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getDoKeyword_0()); }
+
+	'do' 
+
+{ after(grammarAccess.getDoStatementAccess().getDoKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__DoStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__DoStatement__Group__1__Impl
+	rule__DoStatement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getBlockAssignment_1()); }
+(rule__DoStatement__BlockAssignment_1)
+{ after(grammarAccess.getDoStatementAccess().getBlockAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__DoStatement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__DoStatement__Group__2__Impl
+	rule__DoStatement__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getWhileKeyword_2()); }
+
+	'while' 
+
+{ after(grammarAccess.getDoStatementAccess().getWhileKeyword_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__DoStatement__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__DoStatement__Group__3__Impl
+	rule__DoStatement__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getLeftParenthesisKeyword_3()); }
+
+	'(' 
+
+{ after(grammarAccess.getDoStatementAccess().getLeftParenthesisKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__DoStatement__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__DoStatement__Group__4__Impl
+	rule__DoStatement__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getConditionAssignment_4()); }
+(rule__DoStatement__ConditionAssignment_4)
+{ after(grammarAccess.getDoStatementAccess().getConditionAssignment_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__DoStatement__Group__5
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__DoStatement__Group__5__Impl
+	rule__DoStatement__Group__6
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__5__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getRightParenthesisKeyword_5()); }
+
+	')' 
+
+{ after(grammarAccess.getDoStatementAccess().getRightParenthesisKeyword_5()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__DoStatement__Group__6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__DoStatement__Group__6__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DoStatement__Group__6__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getSemicolonKeyword_6()); }
+
+	';' 
+
+{ after(grammarAccess.getDoStatementAccess().getSemicolonKeyword_6()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__ForStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForStatement__Group__0__Impl
+	rule__ForStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getForKeyword_0()); }
+
+	'for' 
+
+{ after(grammarAccess.getForStatementAccess().getForKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ForStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForStatement__Group__1__Impl
+	rule__ForStatement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getLeftParenthesisKeyword_1()); }
+
+	'(' 
+
+{ after(grammarAccess.getForStatementAccess().getLeftParenthesisKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ForStatement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForStatement__Group__2__Impl
+	rule__ForStatement__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForStatement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getControlAssignment_2()); }
+(rule__ForStatement__ControlAssignment_2)
+{ after(grammarAccess.getForStatementAccess().getControlAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ForStatement__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForStatement__Group__3__Impl
+	rule__ForStatement__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForStatement__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_3()); }
+
+	')' 
+
+{ after(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ForStatement__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForStatement__Group__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForStatement__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getBlockAssignment_4()); }
+(rule__ForStatement__BlockAssignment_4)
+{ after(grammarAccess.getForStatementAccess().getBlockAssignment_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__ForControl__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForControl__Group__0__Impl
+	rule__ForControl__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForControl__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_0()); }
+(rule__ForControl__LoopVariableDefinitionAssignment_0)
+{ after(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ForControl__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForControl__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForControl__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForControlAccess().getGroup_1()); }
+(rule__ForControl__Group_1__0)*
+{ after(grammarAccess.getForControlAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ForControl__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForControl__Group_1__0__Impl
+	rule__ForControl__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForControl__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForControlAccess().getCommaKeyword_1_0()); }
+
+	',' 
+
+{ after(grammarAccess.getForControlAccess().getCommaKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ForControl__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ForControl__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForControl__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_1_1()); }
+(rule__ForControl__LoopVariableDefinitionAssignment_1_1)
+{ after(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__LoopVariableDefinition__Group_0__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LoopVariableDefinition__Group_0__0__Impl
+	rule__LoopVariableDefinition__Group_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_0__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_0_0()); }
+(rule__LoopVariableDefinition__NameAssignment_0_0)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_0__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LoopVariableDefinition__Group_0__1__Impl
+	rule__LoopVariableDefinition__Group_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_0__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getInKeyword_0_1()); }
+
+	'in' 
+
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getInKeyword_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_0__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LoopVariableDefinition__Group_0__2__Impl
+	rule__LoopVariableDefinition__Group_0__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_0__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getExpression1Assignment_0_2()); }
+(rule__LoopVariableDefinition__Expression1Assignment_0_2)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getExpression1Assignment_0_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_0__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LoopVariableDefinition__Group_0__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_0__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0_3()); }
+(rule__LoopVariableDefinition__Group_0_3__0)?
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__LoopVariableDefinition__Group_0_3__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LoopVariableDefinition__Group_0_3__0__Impl
+	rule__LoopVariableDefinition__Group_0_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_0_3__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getFullStopFullStopKeyword_0_3_0()); }
+
+	'..' 
+
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getFullStopFullStopKeyword_0_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_0_3__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LoopVariableDefinition__Group_0_3__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_0_3__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getExpression2Assignment_0_3_1()); }
+(rule__LoopVariableDefinition__Expression2Assignment_0_3_1)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getExpression2Assignment_0_3_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__LoopVariableDefinition__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LoopVariableDefinition__Group_1__0__Impl
+	rule__LoopVariableDefinition__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getTypeAssignment_1_0()); }
+(rule__LoopVariableDefinition__TypeAssignment_1_0)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getTypeAssignment_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LoopVariableDefinition__Group_1__1__Impl
+	rule__LoopVariableDefinition__Group_1__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_1_1()); }
+(rule__LoopVariableDefinition__NameAssignment_1_1)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_1__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LoopVariableDefinition__Group_1__2__Impl
+	rule__LoopVariableDefinition__Group_1__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_1__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getColonKeyword_1_2()); }
+
+	':' 
+
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getColonKeyword_1_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__LoopVariableDefinition__Group_1__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__LoopVariableDefinition__Group_1__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Group_1__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getExpressionAssignment_1_3()); }
+(rule__LoopVariableDefinition__ExpressionAssignment_1_3)
+{ after(grammarAccess.getLoopVariableDefinitionAccess().getExpressionAssignment_1_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__BreakStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__BreakStatement__Group__0__Impl
+	rule__BreakStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__BreakStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getBreakStatementAccess().getBreakStatementAction_0()); }
+(
+
+)
+{ after(grammarAccess.getBreakStatementAccess().getBreakStatementAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__BreakStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__BreakStatement__Group__1__Impl
+	rule__BreakStatement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__BreakStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getBreakStatementAccess().getBreakKeyword_1()); }
+
+	'break' 
+
+{ after(grammarAccess.getBreakStatementAccess().getBreakKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__BreakStatement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__BreakStatement__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__BreakStatement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getBreakStatementAccess().getSemicolonKeyword_2()); }
+
+	';' 
+
+{ after(grammarAccess.getBreakStatementAccess().getSemicolonKeyword_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__ReturnStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ReturnStatement__Group__0__Impl
+	rule__ReturnStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ReturnStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getReturnStatementAccess().getReturnKeyword_0()); }
+
+	'return' 
+
+{ after(grammarAccess.getReturnStatementAccess().getReturnKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ReturnStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ReturnStatement__Group__1__Impl
+	rule__ReturnStatement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ReturnStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getReturnStatementAccess().getExpressionAssignment_1()); }
+(rule__ReturnStatement__ExpressionAssignment_1)
+{ after(grammarAccess.getReturnStatementAccess().getExpressionAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ReturnStatement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ReturnStatement__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ReturnStatement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getReturnStatementAccess().getSemicolonKeyword_2()); }
+
+	';' 
+
+{ after(grammarAccess.getReturnStatementAccess().getSemicolonKeyword_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__AcceptStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AcceptStatement__Group__0__Impl
+	rule__AcceptStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptStatementAccess().getClauseAssignment_0()); }
+(rule__AcceptStatement__ClauseAssignment_0)
+{ after(grammarAccess.getAcceptStatementAccess().getClauseAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AcceptStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AcceptStatement__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptStatementAccess().getAlternatives_1()); }
+(rule__AcceptStatement__Alternatives_1)
+{ after(grammarAccess.getAcceptStatementAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__SimpleAcceptStatementCompletion__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SimpleAcceptStatementCompletion__Group__0__Impl
+	rule__SimpleAcceptStatementCompletion__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SimpleAcceptStatementCompletion__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSimpleAcceptStatementCompletionAccess().getSimpleAcceptStatementCompletionAction_0()); }
+(
+
+)
+{ after(grammarAccess.getSimpleAcceptStatementCompletionAccess().getSimpleAcceptStatementCompletionAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SimpleAcceptStatementCompletion__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SimpleAcceptStatementCompletion__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SimpleAcceptStatementCompletion__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSimpleAcceptStatementCompletionAccess().getSemicolonKeyword_1()); }
+
+	';' 
+
+{ after(grammarAccess.getSimpleAcceptStatementCompletionAccess().getSemicolonKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__CompoundAcceptStatementCompletion__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__CompoundAcceptStatementCompletion__Group__0__Impl
+	rule__CompoundAcceptStatementCompletion__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CompoundAcceptStatementCompletion__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockAssignment_0()); }
+(rule__CompoundAcceptStatementCompletion__BlockAssignment_0)
+{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__CompoundAcceptStatementCompletion__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__CompoundAcceptStatementCompletion__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CompoundAcceptStatementCompletion__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup_1()); }
+(rule__CompoundAcceptStatementCompletion__Group_1__0)*
+{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__CompoundAcceptStatementCompletion__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__CompoundAcceptStatementCompletion__Group_1__0__Impl
+	rule__CompoundAcceptStatementCompletion__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CompoundAcceptStatementCompletion__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getOrKeyword_1_0()); }
+
+	'or' 
+
+{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getOrKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__CompoundAcceptStatementCompletion__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__CompoundAcceptStatementCompletion__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CompoundAcceptStatementCompletion__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAssignment_1_1()); }
+(rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1)
+{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AcceptBlock__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AcceptBlock__Group__0__Impl
+	rule__AcceptBlock__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptBlock__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptBlockAccess().getClauseAssignment_0()); }
+(rule__AcceptBlock__ClauseAssignment_0)
+{ after(grammarAccess.getAcceptBlockAccess().getClauseAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AcceptBlock__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AcceptBlock__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptBlock__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptBlockAccess().getBlockAssignment_1()); }
+(rule__AcceptBlock__BlockAssignment_1)
+{ after(grammarAccess.getAcceptBlockAccess().getBlockAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AcceptClause__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AcceptClause__Group__0__Impl
+	rule__AcceptClause__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getAcceptKeyword_0()); }
+
+	'accept' 
+
+{ after(grammarAccess.getAcceptClauseAccess().getAcceptKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AcceptClause__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AcceptClause__Group__1__Impl
+	rule__AcceptClause__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getLeftParenthesisKeyword_1()); }
+
+	'(' 
+
+{ after(grammarAccess.getAcceptClauseAccess().getLeftParenthesisKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AcceptClause__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AcceptClause__Group__2__Impl
+	rule__AcceptClause__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getGroup_2()); }
+(rule__AcceptClause__Group_2__0)?
+{ after(grammarAccess.getAcceptClauseAccess().getGroup_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AcceptClause__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AcceptClause__Group__3__Impl
+	rule__AcceptClause__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getQualifiedNameListAssignment_3()); }
+(rule__AcceptClause__QualifiedNameListAssignment_3)
+{ after(grammarAccess.getAcceptClauseAccess().getQualifiedNameListAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AcceptClause__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AcceptClause__Group__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getRightParenthesisKeyword_4()); }
+
+	')' 
+
+{ after(grammarAccess.getAcceptClauseAccess().getRightParenthesisKeyword_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__AcceptClause__Group_2__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AcceptClause__Group_2__0__Impl
+	rule__AcceptClause__Group_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group_2__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getNameAssignment_2_0()); }
+(rule__AcceptClause__NameAssignment_2_0)
+{ after(grammarAccess.getAcceptClauseAccess().getNameAssignment_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AcceptClause__Group_2__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AcceptClause__Group_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__Group_2__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getColonKeyword_2_1()); }
+
+	':' 
+
+{ after(grammarAccess.getAcceptClauseAccess().getColonKeyword_2_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassifyStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassifyStatement__Group__0__Impl
+	rule__ClassifyStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassifyStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassifyStatementAccess().getClassifyKeyword_0()); }
+
+	'classify' 
+
+{ after(grammarAccess.getClassifyStatementAccess().getClassifyKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ClassifyStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassifyStatement__Group__1__Impl
+	rule__ClassifyStatement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassifyStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassifyStatementAccess().getExpressionAssignment_1()); }
+(rule__ClassifyStatement__ExpressionAssignment_1)
+{ after(grammarAccess.getClassifyStatementAccess().getExpressionAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ClassifyStatement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassifyStatement__Group__2__Impl
+	rule__ClassifyStatement__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassifyStatement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassifyStatementAccess().getClauseAssignment_2()); }
+(rule__ClassifyStatement__ClauseAssignment_2)
+{ after(grammarAccess.getClassifyStatementAccess().getClauseAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ClassifyStatement__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassifyStatement__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassifyStatement__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassifyStatementAccess().getSemicolonKeyword_3()); }
+
+	';' 
+
+{ after(grammarAccess.getClassifyStatementAccess().getSemicolonKeyword_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__ClassificationClause__Group_0__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassificationClause__Group_0__0__Impl
+	rule__ClassificationClause__Group_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__Group_0__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseAssignment_0_0()); }
+(rule__ClassificationClause__ClassifyFromClauseAssignment_0_0)
+{ after(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseAssignment_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ClassificationClause__Group_0__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassificationClause__Group_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__Group_0__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_0_1()); }
+(rule__ClassificationClause__ClassifyToClauseAssignment_0_1)?
+{ after(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassificationClause__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassificationClause__Group_1__0__Impl
+	rule__ClassificationClause__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseAssignment_1_0()); }
+(rule__ClassificationClause__ReclassyAllClauseAssignment_1_0)?
+{ after(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseAssignment_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ClassificationClause__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassificationClause__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_1_1()); }
+(rule__ClassificationClause__ClassifyToClauseAssignment_1_1)
+{ after(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassificationFromClause__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassificationFromClause__Group__0__Impl
+	rule__ClassificationFromClause__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationFromClause__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationFromClauseAccess().getFromKeyword_0()); }
+
+	'from' 
+
+{ after(grammarAccess.getClassificationFromClauseAccess().getFromKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ClassificationFromClause__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassificationFromClause__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationFromClause__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListAssignment_1()); }
+(rule__ClassificationFromClause__QualifiedNameListAssignment_1)
+{ after(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ClassificationToClause__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassificationToClause__Group__0__Impl
+	rule__ClassificationToClause__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationToClause__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationToClauseAccess().getToKeyword_0()); }
+
+	'to' 
+
+{ after(grammarAccess.getClassificationToClauseAccess().getToKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ClassificationToClause__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ClassificationToClause__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationToClause__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListAssignment_1()); }
+(rule__ClassificationToClause__QualifiedNameListAssignment_1)
+{ after(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ReclassifyAllClause__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ReclassifyAllClause__Group__0__Impl
+	rule__ReclassifyAllClause__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ReclassifyAllClause__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getReclassifyAllClauseAccess().getReclassifyAllClauseAction_0()); }
+(
+
+)
+{ after(grammarAccess.getReclassifyAllClauseAccess().getReclassifyAllClauseAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ReclassifyAllClause__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ReclassifyAllClause__Group__1__Impl
+	rule__ReclassifyAllClause__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ReclassifyAllClause__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getReclassifyAllClauseAccess().getFromKeyword_1()); }
+
+	'from' 
+
+{ after(grammarAccess.getReclassifyAllClauseAccess().getFromKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ReclassifyAllClause__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ReclassifyAllClause__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ReclassifyAllClause__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getReclassifyAllClauseAccess().getAsteriskKeyword_2()); }
+
+	'*' 
+
+{ after(grammarAccess.getReclassifyAllClauseAccess().getAsteriskKeyword_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__QualifiedNameList__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__QualifiedNameList__Group__0__Impl
+	rule__QualifiedNameList__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameList__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_0()); }
+(rule__QualifiedNameList__QualifiedNameAssignment_0)
+{ after(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameList__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__QualifiedNameList__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameList__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getGroup_1()); }
+(rule__QualifiedNameList__Group_1__0)*
+{ after(grammarAccess.getQualifiedNameListAccess().getGroup_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__QualifiedNameList__Group_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__QualifiedNameList__Group_1__0__Impl
+	rule__QualifiedNameList__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameList__Group_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getCommaKeyword_1_0()); }
+
+	',' 
+
+{ after(grammarAccess.getQualifiedNameListAccess().getCommaKeyword_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameList__Group_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__QualifiedNameList__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameList__Group_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_1_1()); }
+(rule__QualifiedNameList__QualifiedNameAssignment_1_1)
+{ after(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__InvocationOrAssignementOrDeclarationStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl
+	rule__InvocationOrAssignementOrDeclarationStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartAssignment_0()); }
+(rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0)
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InvocationOrAssignementOrDeclarationStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl
+	rule__InvocationOrAssignementOrDeclarationStatement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAlternatives_1()); }
+(rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1)?
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InvocationOrAssignementOrDeclarationStatement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getSemicolonKeyword_2()); }
+
+	';' 
+
+{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getSemicolonKeyword_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__SuperInvocationStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SuperInvocationStatement__Group__0__Impl
+	rule__SuperInvocationStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSuperInvocationStatementAccess().get_superAssignment_0()); }
+(rule__SuperInvocationStatement___superAssignment_0)
+{ after(grammarAccess.getSuperInvocationStatementAccess().get_superAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__SuperInvocationStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__SuperInvocationStatement__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSuperInvocationStatementAccess().getSemicolonKeyword_1()); }
+
+	';' 
+
+{ after(grammarAccess.getSuperInvocationStatementAccess().getSemicolonKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__ThisInvocationStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ThisInvocationStatement__Group__0__Impl
+	rule__ThisInvocationStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ThisInvocationStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getThisInvocationStatementAccess().get_thisAssignment_0()); }
+(rule__ThisInvocationStatement___thisAssignment_0)
+{ after(grammarAccess.getThisInvocationStatementAccess().get_thisAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ThisInvocationStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ThisInvocationStatement__Group__1__Impl
+	rule__ThisInvocationStatement__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ThisInvocationStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getThisInvocationStatementAccess().getAssignmentCompletionAssignment_1()); }
+(rule__ThisInvocationStatement__AssignmentCompletionAssignment_1)?
+{ after(grammarAccess.getThisInvocationStatementAccess().getAssignmentCompletionAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ThisInvocationStatement__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__ThisInvocationStatement__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ThisInvocationStatement__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getThisInvocationStatementAccess().getSemicolonKeyword_2()); }
+
+	';' 
+
+{ after(grammarAccess.getThisInvocationStatementAccess().getSemicolonKeyword_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__InstanceCreationInvocationStatement__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationInvocationStatement__Group__0__Impl
+	rule__InstanceCreationInvocationStatement__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationInvocationStatement__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationInvocationStatementAccess().get_newAssignment_0()); }
+(rule__InstanceCreationInvocationStatement___newAssignment_0)
+{ after(grammarAccess.getInstanceCreationInvocationStatementAccess().get_newAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__InstanceCreationInvocationStatement__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__InstanceCreationInvocationStatement__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationInvocationStatement__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationInvocationStatementAccess().getSemicolonKeyword_1()); }
+
+	';' 
+
+{ after(grammarAccess.getInstanceCreationInvocationStatementAccess().getSemicolonKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__VariableDeclarationCompletion__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__VariableDeclarationCompletion__Group__0__Impl
+	rule__VariableDeclarationCompletion__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__VariableDeclarationCompletion__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getGroup_0()); }
+(rule__VariableDeclarationCompletion__Group_0__0)?
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getGroup_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__VariableDeclarationCompletion__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__VariableDeclarationCompletion__Group__1__Impl
+	rule__VariableDeclarationCompletion__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__VariableDeclarationCompletion__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getVariableNameAssignment_1()); }
+(rule__VariableDeclarationCompletion__VariableNameAssignment_1)
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getVariableNameAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__VariableDeclarationCompletion__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__VariableDeclarationCompletion__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__VariableDeclarationCompletion__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getInitValueAssignment_2()); }
+(rule__VariableDeclarationCompletion__InitValueAssignment_2)
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getInitValueAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__VariableDeclarationCompletion__Group_0__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__VariableDeclarationCompletion__Group_0__0__Impl
+	rule__VariableDeclarationCompletion__Group_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__VariableDeclarationCompletion__Group_0__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorAssignment_0_0()); }
+(rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0)
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorAssignment_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__VariableDeclarationCompletion__Group_0__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__VariableDeclarationCompletion__Group_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__VariableDeclarationCompletion__Group_0__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getRightSquareBracketKeyword_0_1()); }
+
+	']' 
+
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getRightSquareBracketKeyword_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__AssignmentCompletion__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AssignmentCompletion__Group__0__Impl
+	rule__AssignmentCompletion__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AssignmentCompletion__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAssignmentCompletionAccess().getOpAssignment_0()); }
+(rule__AssignmentCompletion__OpAssignment_0)
+{ after(grammarAccess.getAssignmentCompletionAccess().getOpAssignment_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__AssignmentCompletion__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__AssignmentCompletion__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AssignmentCompletion__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAssignmentCompletionAccess().getRightHandSideAssignment_1()); }
+(rule__AssignmentCompletion__RightHandSideAssignment_1)
+{ after(grammarAccess.getAssignmentCompletionAccess().getRightHandSideAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+rule__Test__ExpressionAssignment_0_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getExpressionExpressionParserRuleCall_0_1_0()); }
+	ruleExpression{ after(grammarAccess.getTestAccess().getExpressionExpressionParserRuleCall_0_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__AssignExpressionAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getAssignExpressionAssignmentCompletionParserRuleCall_1_1_0()); }
+	ruleAssignmentCompletion{ after(grammarAccess.getTestAccess().getAssignExpressionAssignmentCompletionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__StatementsAssignment_2_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getStatementsStatementParserRuleCall_2_1_0()); }
+	ruleStatement{ after(grammarAccess.getTestAccess().getStatementsStatementParserRuleCall_2_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Test__BlockAssignment_3_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTestAccess().getBlockBlockParserRuleCall_3_1_0()); }
+	ruleBlock{ after(grammarAccess.getTestAccess().getBlockBlockParserRuleCall_3_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__BOOLEAN_LITERAL__ValueAssignment
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getBOOLEAN_LITERALAccess().getValueBooleanValueEnumRuleCall_0()); }
+	ruleBooleanValue{ after(grammarAccess.getBOOLEAN_LITERALAccess().getValueBooleanValueEnumRuleCall_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__INTEGER_LITERAL__ValueAssignment
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getINTEGER_LITERALAccess().getValueIntegerValueTerminalRuleCall_0()); }
+	RULE_INTEGERVALUE{ after(grammarAccess.getINTEGER_LITERALAccess().getValueIntegerValueTerminalRuleCall_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__UNLIMITED_LITERAL__ValueAssignment
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getUNLIMITED_LITERALAccess().getValueAsteriskKeyword_0()); }
+(
+{ before(grammarAccess.getUNLIMITED_LITERALAccess().getValueAsteriskKeyword_0()); }
+
+	'*' 
+
+{ after(grammarAccess.getUNLIMITED_LITERALAccess().getValueAsteriskKeyword_0()); }
+)
+
+{ after(grammarAccess.getUNLIMITED_LITERALAccess().getValueAsteriskKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__STRING_LITERAL__ValueAssignment
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSTRING_LITERALAccess().getValueSTRINGTerminalRuleCall_0()); }
+	RULE_STRING{ after(grammarAccess.getSTRING_LITERALAccess().getValueSTRINGTerminalRuleCall_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__PrefixOpAssignment_0_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPrefixOpAlternatives_0_0_0_0()); }
+(rule__NameExpression__PrefixOpAlternatives_0_0_0_0)
+{ after(grammarAccess.getNameExpressionAccess().getPrefixOpAlternatives_0_0_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__PathAssignment_0_0_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPathQualifiedNamePathParserRuleCall_0_0_1_0()); }
+	ruleQualifiedNamePath{ after(grammarAccess.getNameExpressionAccess().getPathQualifiedNamePathParserRuleCall_0_0_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__IdAssignment_0_0_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getIdIDTerminalRuleCall_0_0_2_0()); }
+	RULE_ID{ after(grammarAccess.getNameExpressionAccess().getIdIDTerminalRuleCall_0_0_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__PathAssignment_0_1_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPathQualifiedNamePathParserRuleCall_0_1_0_0()); }
+	ruleQualifiedNamePath{ after(grammarAccess.getNameExpressionAccess().getPathQualifiedNamePathParserRuleCall_0_1_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__IdAssignment_0_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getIdIDTerminalRuleCall_0_1_1_0()); }
+	RULE_ID{ after(grammarAccess.getNameExpressionAccess().getIdIDTerminalRuleCall_0_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__InvocationCompletionAssignment_0_1_2_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getInvocationCompletionTupleParserRuleCall_0_1_2_0_0()); }
+	ruleTuple{ after(grammarAccess.getNameExpressionAccess().getInvocationCompletionTupleParserRuleCall_0_1_2_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionSequenceConstructionOrAccessCompletionParserRuleCall_0_1_2_1_0()); }
+	ruleSequenceConstructionOrAccessCompletion{ after(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionSequenceConstructionOrAccessCompletionParserRuleCall_0_1_2_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__PostfixOpAssignment_0_1_2_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getPostfixOpAlternatives_0_1_2_2_0()); }
+(rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0)
+{ after(grammarAccess.getNameExpressionAccess().getPostfixOpAlternatives_0_1_2_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NameExpression__SuffixAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNameExpressionAccess().getSuffixSuffixExpressionParserRuleCall_1_0()); }
+	ruleSuffixExpression{ after(grammarAccess.getNameExpressionAccess().getSuffixSuffixExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNamePath__NamespaceAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNamePathAccess().getNamespaceUnqualifiedNameParserRuleCall_0_0()); }
+	ruleUnqualifiedName{ after(grammarAccess.getQualifiedNamePathAccess().getNamespaceUnqualifiedNameParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__UnqualifiedName__NameAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getUnqualifiedNameAccess().getNameIDTerminalRuleCall_0_0()); }
+	RULE_ID{ after(grammarAccess.getUnqualifiedNameAccess().getNameIDTerminalRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__UnqualifiedName__TemplateBindingAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingTemplateBindingParserRuleCall_1_0()); }
+	ruleTemplateBinding{ after(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingTemplateBindingParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__BindingsAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getBindingsNamedTemplateBindingParserRuleCall_1_0()); }
+	ruleNamedTemplateBinding{ after(grammarAccess.getTemplateBindingAccess().getBindingsNamedTemplateBindingParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TemplateBinding__BindingsAssignment_2_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTemplateBindingAccess().getBindingsNamedTemplateBindingParserRuleCall_2_1_0()); }
+	ruleNamedTemplateBinding{ after(grammarAccess.getTemplateBindingAccess().getBindingsNamedTemplateBindingParserRuleCall_2_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NamedTemplateBinding__FormalAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNamedTemplateBindingAccess().getFormalIDTerminalRuleCall_0_0()); }
+	RULE_ID{ after(grammarAccess.getNamedTemplateBindingAccess().getFormalIDTerminalRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NamedTemplateBinding__ActualAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNamedTemplateBindingAccess().getActualQualifiedNameWithBindingParserRuleCall_2_0()); }
+	ruleQualifiedNameWithBinding{ after(grammarAccess.getNamedTemplateBindingAccess().getActualQualifiedNameWithBindingParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__IdAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getIdIDTerminalRuleCall_0_0()); }
+	RULE_ID{ after(grammarAccess.getQualifiedNameWithBindingAccess().getIdIDTerminalRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__BindingAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getBindingTemplateBindingParserRuleCall_1_0()); }
+	ruleTemplateBinding{ after(grammarAccess.getQualifiedNameWithBindingAccess().getBindingTemplateBindingParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithBinding__RemainingAssignment_2_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingQualifiedNameWithBindingParserRuleCall_2_1_0()); }
+	ruleQualifiedNameWithBinding{ after(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingQualifiedNameWithBindingParserRuleCall_2_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Tuple__TupleElementsAssignment_2_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTupleAccess().getTupleElementsTupleElementParserRuleCall_2_0_0()); }
+	ruleTupleElement{ after(grammarAccess.getTupleAccess().getTupleElementsTupleElementParserRuleCall_2_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Tuple__TupleElementsAssignment_2_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTupleAccess().getTupleElementsTupleElementParserRuleCall_2_1_1_0()); }
+	ruleTupleElement{ after(grammarAccess.getTupleAccess().getTupleElementsTupleElementParserRuleCall_2_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TupleElement__ArgumentAssignment
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTupleElementAccess().getArgumentExpressionParserRuleCall_0()); }
+	ruleExpression{ after(grammarAccess.getTupleElementAccess().getArgumentExpressionParserRuleCall_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__ExpAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getExpConditionalOrExpressionParserRuleCall_0_0()); }
+	ruleConditionalOrExpression{ after(grammarAccess.getConditionalTestExpressionAccess().getExpConditionalOrExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__WhenTrueAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueConditionalTestExpressionParserRuleCall_1_1_0()); }
+	ruleConditionalTestExpression{ after(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueConditionalTestExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalTestExpression__WhenFalseAssignment_1_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseConditionalTestExpressionParserRuleCall_1_3_0()); }
+	ruleConditionalTestExpression{ after(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseConditionalTestExpressionParserRuleCall_1_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalOrExpression__ExpAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getExpConditionalAndExpressionParserRuleCall_0_0()); }
+	ruleConditionalAndExpression{ after(grammarAccess.getConditionalOrExpressionAccess().getExpConditionalAndExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalOrExpression__ExpAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalOrExpressionAccess().getExpConditionalAndExpressionParserRuleCall_1_1_0()); }
+	ruleConditionalAndExpression{ after(grammarAccess.getConditionalOrExpressionAccess().getExpConditionalAndExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalAndExpression__ExpAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getExpInclusiveOrExpressionParserRuleCall_0_0()); }
+	ruleInclusiveOrExpression{ after(grammarAccess.getConditionalAndExpressionAccess().getExpInclusiveOrExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConditionalAndExpression__ExpAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConditionalAndExpressionAccess().getExpInclusiveOrExpressionParserRuleCall_1_1_0()); }
+	ruleInclusiveOrExpression{ after(grammarAccess.getConditionalAndExpressionAccess().getExpInclusiveOrExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InclusiveOrExpression__ExpAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getExpExclusiveOrExpressionParserRuleCall_0_0()); }
+	ruleExclusiveOrExpression{ after(grammarAccess.getInclusiveOrExpressionAccess().getExpExclusiveOrExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InclusiveOrExpression__ExpAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInclusiveOrExpressionAccess().getExpExclusiveOrExpressionParserRuleCall_1_1_0()); }
+	ruleExclusiveOrExpression{ after(grammarAccess.getInclusiveOrExpressionAccess().getExpExclusiveOrExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ExclusiveOrExpression__ExpAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getExpAndExpressionParserRuleCall_0_0()); }
+	ruleAndExpression{ after(grammarAccess.getExclusiveOrExpressionAccess().getExpAndExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ExclusiveOrExpression__ExpAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getExclusiveOrExpressionAccess().getExpAndExpressionParserRuleCall_1_1_0()); }
+	ruleAndExpression{ after(grammarAccess.getExclusiveOrExpressionAccess().getExpAndExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AndExpression__ExpAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAndExpressionAccess().getExpEqualityExpressionParserRuleCall_0_0()); }
+	ruleEqualityExpression{ after(grammarAccess.getAndExpressionAccess().getExpEqualityExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AndExpression__ExpAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAndExpressionAccess().getExpEqualityExpressionParserRuleCall_1_1_0()); }
+	ruleEqualityExpression{ after(grammarAccess.getAndExpressionAccess().getExpEqualityExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__ExpAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getExpClassificationExpressionParserRuleCall_0_0()); }
+	ruleClassificationExpression{ after(grammarAccess.getEqualityExpressionAccess().getExpClassificationExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__OpAssignment_1_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getOpAlternatives_1_0_0()); }
+(rule__EqualityExpression__OpAlternatives_1_0_0)
+{ after(grammarAccess.getEqualityExpressionAccess().getOpAlternatives_1_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__EqualityExpression__ExpAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getEqualityExpressionAccess().getExpClassificationExpressionParserRuleCall_1_1_0()); }
+	ruleClassificationExpression{ after(grammarAccess.getEqualityExpressionAccess().getExpClassificationExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__ExpAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getExpRelationalExpressionParserRuleCall_0_0()); }
+	ruleRelationalExpression{ after(grammarAccess.getClassificationExpressionAccess().getExpRelationalExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__OpAssignment_1_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getOpAlternatives_1_0_0()); }
+(rule__ClassificationExpression__OpAlternatives_1_0_0)
+{ after(grammarAccess.getClassificationExpressionAccess().getOpAlternatives_1_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationExpression__TypeNameAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationExpressionAccess().getTypeNameNameExpressionParserRuleCall_1_1_0()); }
+	ruleNameExpression{ after(grammarAccess.getClassificationExpressionAccess().getTypeNameNameExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__RelationalExpression__LeftAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getLeftShiftExpressionParserRuleCall_0_0()); }
+	ruleShiftExpression{ after(grammarAccess.getRelationalExpressionAccess().getLeftShiftExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__RelationalExpression__OpAssignment_1_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getOpAlternatives_1_0_0()); }
+(rule__RelationalExpression__OpAlternatives_1_0_0)
+{ after(grammarAccess.getRelationalExpressionAccess().getOpAlternatives_1_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__RelationalExpression__RightAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getRelationalExpressionAccess().getRightShiftExpressionParserRuleCall_1_1_0()); }
+	ruleShiftExpression{ after(grammarAccess.getRelationalExpressionAccess().getRightShiftExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__ExpAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getExpAdditiveExpressionParserRuleCall_0_0()); }
+	ruleAdditiveExpression{ after(grammarAccess.getShiftExpressionAccess().getExpAdditiveExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__OpAssignment_1_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getOpAlternatives_1_0_0()); }
+(rule__ShiftExpression__OpAlternatives_1_0_0)
+{ after(grammarAccess.getShiftExpressionAccess().getOpAlternatives_1_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ShiftExpression__ExpAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getShiftExpressionAccess().getExpAdditiveExpressionParserRuleCall_1_1_0()); }
+	ruleAdditiveExpression{ after(grammarAccess.getShiftExpressionAccess().getExpAdditiveExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AdditiveExpression__ExpAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getExpMultiplicativeExpressionParserRuleCall_0_0()); }
+	ruleMultiplicativeExpression{ after(grammarAccess.getAdditiveExpressionAccess().getExpMultiplicativeExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AdditiveExpression__OpAssignment_1_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getOpAlternatives_1_0_0()); }
+(rule__AdditiveExpression__OpAlternatives_1_0_0)
+{ after(grammarAccess.getAdditiveExpressionAccess().getOpAlternatives_1_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AdditiveExpression__ExpAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAdditiveExpressionAccess().getExpMultiplicativeExpressionParserRuleCall_1_1_0()); }
+	ruleMultiplicativeExpression{ after(grammarAccess.getAdditiveExpressionAccess().getExpMultiplicativeExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__MultiplicativeExpression__ExpAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getExpUnaryExpressionParserRuleCall_0_0()); }
+	ruleUnaryExpression{ after(grammarAccess.getMultiplicativeExpressionAccess().getExpUnaryExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__MultiplicativeExpression__OpAssignment_1_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getOpAlternatives_1_0_0()); }
+(rule__MultiplicativeExpression__OpAlternatives_1_0_0)
+{ after(grammarAccess.getMultiplicativeExpressionAccess().getOpAlternatives_1_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__MultiplicativeExpression__ExpAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getMultiplicativeExpressionAccess().getExpUnaryExpressionParserRuleCall_1_1_0()); }
+	ruleUnaryExpression{ after(grammarAccess.getMultiplicativeExpressionAccess().getExpUnaryExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__UnaryExpression__OpAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getUnaryExpressionAccess().getOpAlternatives_0_0()); }
+(rule__UnaryExpression__OpAlternatives_0_0)
+{ after(grammarAccess.getUnaryExpressionAccess().getOpAlternatives_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__UnaryExpression__ExpAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getUnaryExpressionAccess().getExpPrimaryExpressionParserRuleCall_1_0()); }
+	rulePrimaryExpression{ after(grammarAccess.getUnaryExpressionAccess().getExpPrimaryExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PrimaryExpression__PrefixAssignment
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPrimaryExpressionAccess().getPrefixValueSpecificationParserRuleCall_0()); }
+	ruleValueSpecification{ after(grammarAccess.getPrimaryExpressionAccess().getPrefixValueSpecificationParserRuleCall_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__OperationNameAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getOperationNameIDTerminalRuleCall_1_0()); }
+	RULE_ID{ after(grammarAccess.getOperationCallExpressionAccess().getOperationNameIDTerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__TupleAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getTupleTupleParserRuleCall_2_0()); }
+	ruleTuple{ after(grammarAccess.getOperationCallExpressionAccess().getTupleTupleParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OperationCallExpression__SuffixAssignment_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getOperationCallExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+	ruleSuffixExpression{ after(grammarAccess.getOperationCallExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__PropertyNameAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameIDTerminalRuleCall_1_0()); }
+	RULE_ID{ after(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameIDTerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__IndexAssignment_2_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getIndexExpressionParserRuleCall_2_1_0()); }
+	ruleExpression{ after(grammarAccess.getPropertyCallExpressionAccess().getIndexExpressionParserRuleCall_2_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PropertyCallExpression__SuffixAssignment_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPropertyCallExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+	ruleSuffixExpression{ after(grammarAccess.getPropertyCallExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationExpression__KindAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationExpressionAccess().getKindLinkOperationKindEnumRuleCall_1_0()); }
+	ruleLinkOperationKind{ after(grammarAccess.getLinkOperationExpressionAccess().getKindLinkOperationKindEnumRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationExpression__TupleAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationExpressionAccess().getTupleLinkOperationTupleParserRuleCall_2_0()); }
+	ruleLinkOperationTuple{ after(grammarAccess.getLinkOperationExpressionAccess().getTupleLinkOperationTupleParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementLinkOperationTupleElementParserRuleCall_1_0()); }
+	ruleLinkOperationTupleElement{ after(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementLinkOperationTupleElementParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementLinkOperationTupleElementParserRuleCall_2_1_0()); }
+	ruleLinkOperationTupleElement{ after(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementLinkOperationTupleElementParserRuleCall_2_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__RoleAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getRoleIDTerminalRuleCall_0_0()); }
+	RULE_ID{ after(grammarAccess.getLinkOperationTupleElementAccess().getRoleIDTerminalRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__RoleIndexAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexExpressionParserRuleCall_1_1_0()); }
+	ruleExpression{ after(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexExpressionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LinkOperationTupleElement__ObjectAssignment_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLinkOperationTupleElementAccess().getObjectExpressionParserRuleCall_3_0()); }
+	ruleExpression{ after(grammarAccess.getLinkOperationTupleElementAccess().getObjectExpressionParserRuleCall_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__OperationNameAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameQualifiedNameWithBindingParserRuleCall_1_0()); }
+	ruleQualifiedNameWithBinding{ after(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameQualifiedNameWithBindingParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__TupleAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getTupleTupleParserRuleCall_2_0()); }
+	ruleTuple{ after(grammarAccess.getSequenceOperationExpressionAccess().getTupleTupleParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceOperationExpression__SuffixAssignment_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceOperationExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+	ruleSuffixExpression{ after(grammarAccess.getSequenceOperationExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__IsOrderedAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedOrderedKeyword_2_0()); }
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedOrderedKeyword_2_0()); }
+
+	'ordered' 
+
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedOrderedKeyword_2_0()); }
+)
+
+{ after(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedOrderedKeyword_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__BehaviorAssignment_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorQualifiedNameWithBindingParserRuleCall_3_0()); }
+	ruleQualifiedNameWithBinding{ after(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorQualifiedNameWithBindingParserRuleCall_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceReductionExpression__SuffixAssignment_4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceReductionExpressionAccess().getSuffixSuffixExpressionParserRuleCall_4_0()); }
+	ruleSuffixExpression{ after(grammarAccess.getSequenceReductionExpressionAccess().getSuffixSuffixExpressionParserRuleCall_4_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__OpAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getOpSelectOrRejectOperatorEnumRuleCall_1_0()); }
+	ruleSelectOrRejectOperator{ after(grammarAccess.getSelectOrRejectOperationAccess().getOpSelectOrRejectOperatorEnumRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__NameAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+	RULE_ID{ after(grammarAccess.getSelectOrRejectOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__ExprAssignment_4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+	ruleExpression{ after(grammarAccess.getSelectOrRejectOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SelectOrRejectOperation__SuffixAssignment_6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSelectOrRejectOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+	ruleSuffixExpression{ after(grammarAccess.getSelectOrRejectOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__OpAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getOpCollectOrIterateOperatorEnumRuleCall_1_0()); }
+	ruleCollectOrIterateOperator{ after(grammarAccess.getCollectOrIterateOperationAccess().getOpCollectOrIterateOperatorEnumRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__NameAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+	RULE_ID{ after(grammarAccess.getCollectOrIterateOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__ExprAssignment_4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+	ruleExpression{ after(grammarAccess.getCollectOrIterateOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CollectOrIterateOperation__SuffixAssignment_6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCollectOrIterateOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+	ruleSuffixExpression{ after(grammarAccess.getCollectOrIterateOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__OpAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpForAllOrExistsOrOneOperatorEnumRuleCall_1_0()); }
+	ruleForAllOrExistsOrOneOperator{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpForAllOrExistsOrOneOperatorEnumRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__NameAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+	RULE_ID{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__ExprAssignment_4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+	ruleExpression{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+	ruleSuffixExpression{ after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__NameAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+	RULE_ID{ after(grammarAccess.getIsUniqueOperationAccess().getNameIDTerminalRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__ExprAssignment_4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+	ruleExpression{ after(grammarAccess.getIsUniqueOperationAccess().getExprExpressionParserRuleCall_4_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IsUniqueOperation__SuffixAssignment_6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIsUniqueOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+	ruleSuffixExpression{ after(grammarAccess.getIsUniqueOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastExpressionParserRuleCall_1_0()); }
+	ruleExpression{ after(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__CastedAssignment_3_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getCastedNonLiteralValueSpecificationParserRuleCall_3_0_0()); }
+	ruleNonLiteralValueSpecification{ after(grammarAccess.getParenthesizedExpressionAccess().getCastedNonLiteralValueSpecificationParserRuleCall_3_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ParenthesizedExpression__SuffixAssignment_3_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getParenthesizedExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_1_0()); }
+	ruleSuffixExpression{ after(grammarAccess.getParenthesizedExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ThisExpression__SuffixAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getThisExpressionAccess().getSuffixSuffixExpressionParserRuleCall_2_0()); }
+	ruleSuffixExpression{ after(grammarAccess.getThisExpressionAccess().getSuffixSuffixExpressionParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__TupleAssignment_1_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getTupleTupleParserRuleCall_1_0_0()); }
+	ruleTuple{ after(grammarAccess.getSuperInvocationExpressionAccess().getTupleTupleParserRuleCall_1_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__OperationNameAssignment_1_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameQualifiedNameWithBindingParserRuleCall_1_1_1_0()); }
+	ruleQualifiedNameWithBinding{ after(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameQualifiedNameWithBindingParserRuleCall_1_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationExpression__TupleAssignment_1_1_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSuperInvocationExpressionAccess().getTupleTupleParserRuleCall_1_1_2_0()); }
+	ruleTuple{ after(grammarAccess.getSuperInvocationExpressionAccess().getTupleTupleParserRuleCall_1_1_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__ConstructorAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getConstructorQualifiedNameWithBindingParserRuleCall_1_0()); }
+	ruleQualifiedNameWithBinding{ after(grammarAccess.getInstanceCreationExpressionAccess().getConstructorQualifiedNameWithBindingParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__TupleAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getTupleInstanceCreationTupleParserRuleCall_2_0()); }
+	ruleInstanceCreationTuple{ after(grammarAccess.getInstanceCreationExpressionAccess().getTupleInstanceCreationTupleParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationExpression__SuffixAssignment_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+	ruleSuffixExpression{ after(grammarAccess.getInstanceCreationExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementInstanceCreationTupleElementParserRuleCall_2_0_0()); }
+	ruleInstanceCreationTupleElement{ after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementInstanceCreationTupleElementParserRuleCall_2_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementInstanceCreationTupleElementParserRuleCall_2_1_1_0()); }
+	ruleInstanceCreationTupleElement{ after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementInstanceCreationTupleElementParserRuleCall_2_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTupleElement__RoleAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleElementAccess().getRoleIDTerminalRuleCall_0_0()); }
+	RULE_ID{ after(grammarAccess.getInstanceCreationTupleElementAccess().getRoleIDTerminalRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationTupleElement__ObjectAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationTupleElementAccess().getObjectExpressionParserRuleCall_2_0()); }
+	ruleExpression{ after(grammarAccess.getInstanceCreationTupleElementAccess().getObjectExpressionParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); }
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); }
+
+	'[' 
+
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); }
+)
+
+{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAccessCompletionParserRuleCall_0_1_0_0()); }
+	ruleAccessCompletion{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAccessCompletionParserRuleCall_0_1_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionPartialSequenceConstructionCompletionParserRuleCall_0_1_1_0()); }
+	rulePartialSequenceConstructionCompletion{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionPartialSequenceConstructionCompletionParserRuleCall_0_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionSequenceConstructionExpressionParserRuleCall_1_0()); }
+	ruleSequenceConstructionExpression{ after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionSequenceConstructionExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AccessCompletion__AccessIndexAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAccessCompletionAccess().getAccessIndexExpressionParserRuleCall_0_0()); }
+	ruleExpression{ after(grammarAccess.getAccessCompletionAccess().getAccessIndexExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionSequenceConstructionExpressionParserRuleCall_1_0()); }
+	ruleSequenceConstructionExpression{ after(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionSequenceConstructionExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__SequenceElementAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementSequenceElementParserRuleCall_1_0()); }
+	ruleSequenceElement{ after(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementSequenceElementParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementSequenceElementParserRuleCall_2_0_1_0()); }
+	ruleSequenceElement{ after(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementSequenceElementParserRuleCall_2_0_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperExpressionParserRuleCall_2_1_1_0()); }
+	ruleExpression{ after(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperExpressionParserRuleCall_2_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Block__SequenceAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getBlockAccess().getSequenceStatementSequenceParserRuleCall_2_0()); }
+	ruleStatementSequence{ after(grammarAccess.getBlockAccess().getSequenceStatementSequenceParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__StatementSequence__StatementsAssignment
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getStatementSequenceAccess().getStatementsDocumentedStatementParserRuleCall_0()); }
+	ruleDocumentedStatement{ after(grammarAccess.getStatementSequenceAccess().getStatementsDocumentedStatementParserRuleCall_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DocumentedStatement__CommentAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDocumentedStatementAccess().getCommentAlternatives_0_0()); }
+(rule__DocumentedStatement__CommentAlternatives_0_0)
+{ after(grammarAccess.getDocumentedStatementAccess().getCommentAlternatives_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DocumentedStatement__StatementAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDocumentedStatementAccess().getStatementStatementParserRuleCall_1_0()); }
+	ruleStatement{ after(grammarAccess.getDocumentedStatementAccess().getStatementStatementParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__LangageNameAssignment_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getLangageNameIDTerminalRuleCall_3_0()); }
+	RULE_ID{ after(grammarAccess.getInlineStatementAccess().getLangageNameIDTerminalRuleCall_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InlineStatement__BodyAssignment_5
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInlineStatementAccess().getBodySTRINGTerminalRuleCall_5_0()); }
+	RULE_STRING{ after(grammarAccess.getInlineStatementAccess().getBodySTRINGTerminalRuleCall_5_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AnnotatedStatement__AnnotationAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotatedStatementAccess().getAnnotationAnnotationParserRuleCall_1_0()); }
+	ruleAnnotation{ after(grammarAccess.getAnnotatedStatementAccess().getAnnotationAnnotationParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AnnotatedStatement__StatementAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotatedStatementAccess().getStatementStatementParserRuleCall_2_0()); }
+	ruleStatement{ after(grammarAccess.getAnnotatedStatementAccess().getStatementStatementParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Annotation__KindAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getKindAnnotationKindEnumRuleCall_0_0()); }
+	ruleAnnotationKind{ after(grammarAccess.getAnnotationAccess().getKindAnnotationKindEnumRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Annotation__ArgsAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getArgsIDTerminalRuleCall_1_1_0()); }
+	RULE_ID{ after(grammarAccess.getAnnotationAccess().getArgsIDTerminalRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Annotation__ArgsAssignment_1_2_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAnnotationAccess().getArgsIDTerminalRuleCall_1_2_1_0()); }
+	RULE_ID{ after(grammarAccess.getAnnotationAccess().getArgsIDTerminalRuleCall_1_2_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__BlockStatement__BlockAssignment
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getBlockStatementAccess().getBlockBlockParserRuleCall_0()); }
+	ruleBlock{ after(grammarAccess.getBlockStatementAccess().getBlockBlockParserRuleCall_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__VarNameAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameIDTerminalRuleCall_1_0()); }
+	RULE_ID{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameIDTerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__TypeAssignment_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeQualifiedNameWithBindingParserRuleCall_3_0()); }
+	ruleQualifiedNameWithBinding{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeQualifiedNameWithBindingParserRuleCall_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_4_0_0()); }
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_4_0_0()); }
+
+	'[' 
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_4_0_0()); }
+)
+
+{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_4_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LocalNameDeclarationStatement__InitAssignment_6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLocalNameDeclarationStatementAccess().getInitSequenceElementParserRuleCall_6_0()); }
+	ruleSequenceElement{ after(grammarAccess.getLocalNameDeclarationStatementAccess().getInitSequenceElementParserRuleCall_6_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IfStatement__SequentialClaussesAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIfStatementAccess().getSequentialClaussesSequentialClausesParserRuleCall_1_0()); }
+	ruleSequentialClauses{ after(grammarAccess.getIfStatementAccess().getSequentialClaussesSequentialClausesParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IfStatement__FinalClauseAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getIfStatementAccess().getFinalClauseFinalClauseParserRuleCall_2_0()); }
+	ruleFinalClause{ after(grammarAccess.getIfStatementAccess().getFinalClauseFinalClauseParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__ConccurentClausesAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getConccurentClausesConcurrentClausesParserRuleCall_0_0()); }
+	ruleConcurrentClauses{ after(grammarAccess.getSequentialClausesAccess().getConccurentClausesConcurrentClausesParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SequentialClauses__ConccurentClausesAssignment_1_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSequentialClausesAccess().getConccurentClausesConcurrentClausesParserRuleCall_1_2_0()); }
+	ruleConcurrentClauses{ after(grammarAccess.getSequentialClausesAccess().getConccurentClausesConcurrentClausesParserRuleCall_1_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__NonFinalClauseAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_0_0()); }
+	ruleNonFinalClause{ after(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ConcurrentClauses__NonFinalClauseAssignment_1_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_1_2_0()); }
+	ruleNonFinalClause{ after(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_1_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NonFinalClause__ConditionAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getConditionExpressionParserRuleCall_1_0()); }
+	ruleExpression{ after(grammarAccess.getNonFinalClauseAccess().getConditionExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NonFinalClause__BlockAssignment_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNonFinalClauseAccess().getBlockBlockParserRuleCall_3_0()); }
+	ruleBlock{ after(grammarAccess.getNonFinalClauseAccess().getBlockBlockParserRuleCall_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__FinalClause__BlockAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getFinalClauseAccess().getBlockBlockParserRuleCall_1_0()); }
+	ruleBlock{ after(grammarAccess.getFinalClauseAccess().getBlockBlockParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__ExpressionAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getExpressionExpressionParserRuleCall_2_0()); }
+	ruleExpression{ after(grammarAccess.getSwitchStatementAccess().getExpressionExpressionParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__SwitchClauseAssignment_5
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getSwitchClauseSwitchClauseParserRuleCall_5_0()); }
+	ruleSwitchClause{ after(grammarAccess.getSwitchStatementAccess().getSwitchClauseSwitchClauseParserRuleCall_5_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchStatement__DefaultClauseAssignment_6
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchStatementAccess().getDefaultClauseSwitchDefaultClauseParserRuleCall_6_0()); }
+	ruleSwitchDefaultClause{ after(grammarAccess.getSwitchStatementAccess().getDefaultClauseSwitchDefaultClauseParserRuleCall_6_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchClause__SwitchCaseAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_0_0()); }
+	ruleSwitchCase{ after(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchClause__SwitchCaseAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_1_0()); }
+	ruleSwitchCase{ after(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchClause__StatementSequenceAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0()); }
+	ruleNonEmptyStatementSequence{ after(grammarAccess.getSwitchClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchCase__ExpressionAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchCaseAccess().getExpressionExpressionParserRuleCall_1_0()); }
+	ruleExpression{ after(grammarAccess.getSwitchCaseAccess().getExpressionExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SwitchDefaultClause__StatementSequenceAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0()); }
+	ruleNonEmptyStatementSequence{ after(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__NonEmptyStatementSequence__StatementAssignment
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementDocumentedStatementParserRuleCall_0()); }
+	ruleDocumentedStatement{ after(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementDocumentedStatementParserRuleCall_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__ConditionAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getConditionExpressionParserRuleCall_2_0()); }
+	ruleExpression{ after(grammarAccess.getWhileStatementAccess().getConditionExpressionParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__WhileStatement__BlockAssignment_4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getWhileStatementAccess().getBlockBlockParserRuleCall_4_0()); }
+	ruleBlock{ after(grammarAccess.getWhileStatementAccess().getBlockBlockParserRuleCall_4_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DoStatement__BlockAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getBlockBlockParserRuleCall_1_0()); }
+	ruleBlock{ after(grammarAccess.getDoStatementAccess().getBlockBlockParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__DoStatement__ConditionAssignment_4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getDoStatementAccess().getConditionExpressionParserRuleCall_4_0()); }
+	ruleExpression{ after(grammarAccess.getDoStatementAccess().getConditionExpressionParserRuleCall_4_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForStatement__ControlAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getControlForControlParserRuleCall_2_0()); }
+	ruleForControl{ after(grammarAccess.getForStatementAccess().getControlForControlParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForStatement__BlockAssignment_4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForStatementAccess().getBlockBlockParserRuleCall_4_0()); }
+	ruleBlock{ after(grammarAccess.getForStatementAccess().getBlockBlockParserRuleCall_4_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForControl__LoopVariableDefinitionAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_0_0()); }
+	ruleLoopVariableDefinition{ after(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ForControl__LoopVariableDefinitionAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_1_1_0()); }
+	ruleLoopVariableDefinition{ after(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__NameAssignment_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getNameIDTerminalRuleCall_0_0_0()); }
+	RULE_ID{ after(grammarAccess.getLoopVariableDefinitionAccess().getNameIDTerminalRuleCall_0_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Expression1Assignment_0_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getExpression1ExpressionParserRuleCall_0_2_0()); }
+	ruleExpression{ after(grammarAccess.getLoopVariableDefinitionAccess().getExpression1ExpressionParserRuleCall_0_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__Expression2Assignment_0_3_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getExpression2ExpressionParserRuleCall_0_3_1_0()); }
+	ruleExpression{ after(grammarAccess.getLoopVariableDefinitionAccess().getExpression2ExpressionParserRuleCall_0_3_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__TypeAssignment_1_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getTypeQualifiedNameWithBindingParserRuleCall_1_0_0()); }
+	ruleQualifiedNameWithBinding{ after(grammarAccess.getLoopVariableDefinitionAccess().getTypeQualifiedNameWithBindingParserRuleCall_1_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__NameAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getNameIDTerminalRuleCall_1_1_0()); }
+	RULE_ID{ after(grammarAccess.getLoopVariableDefinitionAccess().getNameIDTerminalRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LoopVariableDefinition__ExpressionAssignment_1_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLoopVariableDefinitionAccess().getExpressionExpressionParserRuleCall_1_3_0()); }
+	ruleExpression{ after(grammarAccess.getLoopVariableDefinitionAccess().getExpressionExpressionParserRuleCall_1_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ReturnStatement__ExpressionAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getReturnStatementAccess().getExpressionExpressionParserRuleCall_1_0()); }
+	ruleExpression{ after(grammarAccess.getReturnStatementAccess().getExpressionExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptStatement__ClauseAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptStatementAccess().getClauseAcceptClauseParserRuleCall_0_0()); }
+	ruleAcceptClause{ after(grammarAccess.getAcceptStatementAccess().getClauseAcceptClauseParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptStatement__SimpleAcceptAssignment_1_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptStatementAccess().getSimpleAcceptSimpleAcceptStatementCompletionParserRuleCall_1_0_0()); }
+	ruleSimpleAcceptStatementCompletion{ after(grammarAccess.getAcceptStatementAccess().getSimpleAcceptSimpleAcceptStatementCompletionParserRuleCall_1_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptStatement__CompoundAcceptAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptStatementAccess().getCompoundAcceptCompoundAcceptStatementCompletionParserRuleCall_1_1_0()); }
+	ruleCompoundAcceptStatementCompletion{ after(grammarAccess.getAcceptStatementAccess().getCompoundAcceptCompoundAcceptStatementCompletionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CompoundAcceptStatementCompletion__BlockAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockBlockParserRuleCall_0_0()); }
+	ruleBlock{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockBlockParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAcceptBlockParserRuleCall_1_1_0()); }
+	ruleAcceptBlock{ after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAcceptBlockParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptBlock__ClauseAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptBlockAccess().getClauseAcceptClauseParserRuleCall_0_0()); }
+	ruleAcceptClause{ after(grammarAccess.getAcceptBlockAccess().getClauseAcceptClauseParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptBlock__BlockAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptBlockAccess().getBlockBlockParserRuleCall_1_0()); }
+	ruleBlock{ after(grammarAccess.getAcceptBlockAccess().getBlockBlockParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__NameAssignment_2_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getNameIDTerminalRuleCall_2_0_0()); }
+	RULE_ID{ after(grammarAccess.getAcceptClauseAccess().getNameIDTerminalRuleCall_2_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AcceptClause__QualifiedNameListAssignment_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAcceptClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_3_0()); }
+	ruleQualifiedNameList{ after(grammarAccess.getAcceptClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassifyStatement__ExpressionAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassifyStatementAccess().getExpressionExpressionParserRuleCall_1_0()); }
+	ruleExpression{ after(grammarAccess.getClassifyStatementAccess().getExpressionExpressionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassifyStatement__ClauseAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassifyStatementAccess().getClauseClassificationClauseParserRuleCall_2_0()); }
+	ruleClassificationClause{ after(grammarAccess.getClassifyStatementAccess().getClauseClassificationClauseParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__ClassifyFromClauseAssignment_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseClassificationFromClauseParserRuleCall_0_0_0()); }
+	ruleClassificationFromClause{ after(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseClassificationFromClauseParserRuleCall_0_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__ClassifyToClauseAssignment_0_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getClassifyToClauseClassificationToClauseParserRuleCall_0_1_0()); }
+	ruleClassificationToClause{ after(grammarAccess.getClassificationClauseAccess().getClassifyToClauseClassificationToClauseParserRuleCall_0_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__ReclassyAllClauseAssignment_1_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseReclassifyAllClauseParserRuleCall_1_0_0()); }
+	ruleReclassifyAllClause{ after(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseReclassifyAllClauseParserRuleCall_1_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationClause__ClassifyToClauseAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationClauseAccess().getClassifyToClauseClassificationToClauseParserRuleCall_1_1_0()); }
+	ruleClassificationToClause{ after(grammarAccess.getClassificationClauseAccess().getClassifyToClauseClassificationToClauseParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationFromClause__QualifiedNameListAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0()); }
+	ruleQualifiedNameList{ after(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ClassificationToClause__QualifiedNameListAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0()); }
+	ruleQualifiedNameList{ after(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameList__QualifiedNameAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameWithBindingParserRuleCall_0_0()); }
+	ruleQualifiedNameWithBinding{ after(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameWithBindingParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameList__QualifiedNameAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameWithBindingParserRuleCall_1_1_0()); }
+	ruleQualifiedNameWithBinding{ after(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameWithBindingParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartNameExpressionParserRuleCall_0_0()); }
+	ruleNameExpression{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartNameExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionVariableDeclarationCompletionParserRuleCall_1_0_0()); }
+	ruleVariableDeclarationCompletion{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionVariableDeclarationCompletionParserRuleCall_1_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignmentCompletionParserRuleCall_1_1_0()); }
+	ruleAssignmentCompletion{ after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignmentCompletionParserRuleCall_1_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__SuperInvocationStatement___superAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getSuperInvocationStatementAccess().get_superSuperInvocationExpressionParserRuleCall_0_0()); }
+	ruleSuperInvocationExpression{ after(grammarAccess.getSuperInvocationStatementAccess().get_superSuperInvocationExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ThisInvocationStatement___thisAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getThisInvocationStatementAccess().get_thisThisExpressionParserRuleCall_0_0()); }
+	ruleThisExpression{ after(grammarAccess.getThisInvocationStatementAccess().get_thisThisExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ThisInvocationStatement__AssignmentCompletionAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getThisInvocationStatementAccess().getAssignmentCompletionAssignmentCompletionParserRuleCall_1_0()); }
+	ruleAssignmentCompletion{ after(grammarAccess.getThisInvocationStatementAccess().getAssignmentCompletionAssignmentCompletionParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__InstanceCreationInvocationStatement___newAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getInstanceCreationInvocationStatementAccess().get_newInstanceCreationExpressionParserRuleCall_0_0()); }
+	ruleInstanceCreationExpression{ after(grammarAccess.getInstanceCreationInvocationStatementAccess().get_newInstanceCreationExpressionParserRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); }
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); }
+
+	'[' 
+
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); }
+)
+
+{ after(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__VariableDeclarationCompletion__VariableNameAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getVariableNameIDTerminalRuleCall_1_0()); }
+	RULE_ID{ after(grammarAccess.getVariableDeclarationCompletionAccess().getVariableNameIDTerminalRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__VariableDeclarationCompletion__InitValueAssignment_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getVariableDeclarationCompletionAccess().getInitValueAssignmentCompletionParserRuleCall_2_0()); }
+	ruleAssignmentCompletion{ after(grammarAccess.getVariableDeclarationCompletionAccess().getInitValueAssignmentCompletionParserRuleCall_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AssignmentCompletion__OpAssignment_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAssignmentCompletionAccess().getOpAssignmentOperatorEnumRuleCall_0_0()); }
+	ruleAssignmentOperator{ after(grammarAccess.getAssignmentCompletionAccess().getOpAssignmentOperatorEnumRuleCall_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AssignmentCompletion__RightHandSideAssignment_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAssignmentCompletionAccess().getRightHandSideSequenceElementParserRuleCall_1_0()); }
+	ruleSequenceElement{ after(grammarAccess.getAssignmentCompletionAccess().getRightHandSideSequenceElementParserRuleCall_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+RULE_INTEGERVALUE : (('0'|'1'..'9' ('_'? '0'..'9')*)|('0b'|'0B') '0'..'1' ('_'? '0'..'1')*|('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F') ('_'? ('0'..'9'|'a'..'f'|'A'..'F'))*|'0' '_'? '0'..'7' ('_'? '0'..'7')*);
+
+RULE_ID : (('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*|'\'' ( options {greedy=false;} : . )*'\'');
+
+RULE_STRING : '"' ('\\' ('b'|'t'|'n'|'f'|'r'|'"'|'\''|'\\')|~(('\\'|'"')))* '"';
+
+RULE_ML_COMMENT : '/*' ~('@') ( options {greedy=false;} : . )*'*/';
+
+RULE_SL_COMMENT : '//' ~(('\n'|'\r'|'@'))* ('\r'? '\n')?;
+
+RULE_INT : ('0'..'9')+;
+
+RULE_WS : (' '|'\t'|'\r'|'\n')+;
+
+RULE_ANY_OTHER : .;
+
+
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.tokens b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.tokens
new file mode 100644
index 00000000000..00283070324
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.tokens
@@ -0,0 +1,212 @@
+RULE_ID=8

+T__29=29

+T__28=28

+T__27=27

+T__26=26

+T__25=25

+T__24=24

+T__23=23

+T__22=22

+RULE_ANY_OTHER=11

+T__21=21

+T__20=20

+T__93=93

+T__19=19

+T__94=94

+T__91=91

+T__92=92

+T__16=16

+T__15=15

+T__90=90

+T__18=18

+T__17=17

+T__12=12

+T__14=14

+T__13=13

+T__99=99

+RULE_INTEGERVALUE=6

+T__98=98

+T__97=97

+T__96=96

+T__95=95

+T__80=80

+T__81=81

+T__82=82

+T__83=83

+T__85=85

+T__84=84

+T__87=87

+T__86=86

+T__89=89

+T__88=88

+RULE_ML_COMMENT=4

+RULE_STRING=7

+T__71=71

+T__72=72

+T__70=70

+T__76=76

+T__75=75

+T__74=74

+T__73=73

+T__79=79

+T__78=78

+T__77=77

+T__68=68

+T__69=69

+T__66=66

+T__67=67

+T__64=64

+T__65=65

+T__62=62

+T__63=63

+T__61=61

+T__60=60

+T__55=55

+T__56=56

+T__57=57

+T__58=58

+T__51=51

+T__52=52

+T__53=53

+T__54=54

+T__107=107

+T__108=108

+T__109=109

+T__103=103

+T__59=59

+T__104=104

+T__105=105

+T__106=106

+T__111=111

+T__110=110

+RULE_INT=9

+T__113=113

+T__112=112

+T__50=50

+T__42=42

+T__43=43

+T__40=40

+T__41=41

+T__46=46

+T__47=47

+T__44=44

+T__45=45

+T__48=48

+T__49=49

+T__102=102

+T__101=101

+T__100=100

+RULE_SL_COMMENT=5

+T__30=30

+T__31=31

+T__32=32

+T__33=33

+T__34=34

+T__35=35

+T__36=36

+T__37=37

+T__38=38

+T__39=39

+RULE_WS=10

+'>='=21

+'=='=14

+'iterate'=41

+'this'=84

+';'=95

+'return'=108

+'for'=105

+'/*@'=91

+'=>'=67

+'^'=75

+'parallel'=48

+'>>'=23

+'testExpression'=61

+'isolated'=45

+'{'=87

+'&='=55

+'('=68

+':'=71

+'default'=102

+'<<='=58

+'>>>'=24

+'testBlock'=64

+']'=79

+'ordered'=113

+'new'=86

+'|='=56

+'forAll'=42

+'='=49

+'destroyLink'=36

+'testStatement'=63

+'collect'=40

+'reduce'=81

+'isUnique'=82

+'%'=29

+'->'=80

+'super'=85

+'case'=101

+'reject'=39

+'<<'=22

+'<='=20

+'!='=15

+'<'=18

+'--'=13

+'createLink'=35

+'['=78

+'or'=99

+'//@'=94

+'&'=76

+'instanceof'=16

+'determined'=46

+'accept'=109

+'assured'=47

+'clearAssoc'=37

+'~'=32

+'/'=28

+'/='=54

+'switch'=100

+'%='=53

+'exists'=43

+'>'=19

+'||'=72

+'&&'=73

+'+'=25

+'.'=77

+'$'=31

+'++'=12

+'true'=33

+'else'=98

+'^='=57

+'+='=50

+'let'=96

+'break'=107

+'*/'=93

+'allInstances'=90

+'>>='=59

+'>>>='=60

+'?'=70

+'testAssignmentExpression'=62

+'if'=97

+'-'=26

+'while'=103

+','=66

+'select'=38

+'in'=106

+'-='=51

+'..'=89

+'!'=30

+'|'=74

+'null'=83

+'classify'=110

+'one'=44

+'::'=65

+'inline'=92

+'hastype'=17

+')'=69

+'*='=52

+'do'=104

+'}'=88

+'to'=112

+'false'=34

+'*'=27

+'from'=111

diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlfLexer.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlfLexer.java
new file mode 100644
index 00000000000..0cb898adb1a
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlfLexer.java
@@ -0,0 +1,4658 @@
+package org.eclipse.papyrus.alf.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;

+

+

+import org.antlr.runtime.*;

+import java.util.Stack;

+import java.util.List;

+import java.util.ArrayList;

+

+@SuppressWarnings("all")
+public class InternalAlfLexer extends Lexer {

+    public static final int RULE_ID=8;

+    public static final int T__29=29;

+    public static final int T__28=28;

+    public static final int T__27=27;

+    public static final int T__26=26;

+    public static final int T__25=25;

+    public static final int T__24=24;

+    public static final int T__23=23;

+    public static final int T__22=22;

+    public static final int RULE_ANY_OTHER=11;

+    public static final int T__21=21;

+    public static final int T__20=20;

+    public static final int EOF=-1;

+    public static final int T__93=93;

+    public static final int T__19=19;

+    public static final int T__94=94;

+    public static final int T__91=91;

+    public static final int T__92=92;

+    public static final int T__16=16;

+    public static final int T__90=90;

+    public static final int T__15=15;

+    public static final int T__18=18;

+    public static final int T__17=17;

+    public static final int T__12=12;

+    public static final int T__14=14;

+    public static final int T__13=13;

+    public static final int T__99=99;

+    public static final int T__98=98;

+    public static final int RULE_INTEGERVALUE=6;

+    public static final int T__97=97;

+    public static final int T__96=96;

+    public static final int T__95=95;

+    public static final int T__80=80;

+    public static final int T__81=81;

+    public static final int T__82=82;

+    public static final int T__83=83;

+    public static final int T__85=85;

+    public static final int T__84=84;

+    public static final int T__87=87;

+    public static final int T__86=86;

+    public static final int T__89=89;

+    public static final int T__88=88;

+    public static final int RULE_ML_COMMENT=4;

+    public static final int RULE_STRING=7;

+    public static final int T__71=71;

+    public static final int T__72=72;

+    public static final int T__70=70;

+    public static final int T__76=76;

+    public static final int T__75=75;

+    public static final int T__74=74;

+    public static final int T__73=73;

+    public static final int T__79=79;

+    public static final int T__78=78;

+    public static final int T__77=77;

+    public static final int T__68=68;

+    public static final int T__69=69;

+    public static final int T__66=66;

+    public static final int T__67=67;

+    public static final int T__64=64;

+    public static final int T__65=65;

+    public static final int T__62=62;

+    public static final int T__63=63;

+    public static final int T__61=61;

+    public static final int T__60=60;

+    public static final int T__55=55;

+    public static final int T__56=56;

+    public static final int T__57=57;

+    public static final int T__58=58;

+    public static final int T__51=51;

+    public static final int T__52=52;

+    public static final int T__53=53;

+    public static final int T__54=54;

+    public static final int T__107=107;

+    public static final int T__108=108;

+    public static final int T__109=109;

+    public static final int T__103=103;

+    public static final int T__59=59;

+    public static final int T__104=104;

+    public static final int T__105=105;

+    public static final int T__106=106;

+    public static final int T__111=111;

+    public static final int T__110=110;

+    public static final int RULE_INT=9;

+    public static final int T__113=113;

+    public static final int T__112=112;

+    public static final int T__50=50;

+    public static final int T__42=42;

+    public static final int T__43=43;

+    public static final int T__40=40;

+    public static final int T__41=41;

+    public static final int T__46=46;

+    public static final int T__47=47;

+    public static final int T__44=44;

+    public static final int T__45=45;

+    public static final int T__48=48;

+    public static final int T__49=49;

+    public static final int T__102=102;

+    public static final int T__101=101;

+    public static final int T__100=100;

+    public static final int RULE_SL_COMMENT=5;

+    public static final int T__30=30;

+    public static final int T__31=31;

+    public static final int T__32=32;

+    public static final int T__33=33;

+    public static final int T__34=34;

+    public static final int T__35=35;

+    public static final int T__36=36;

+    public static final int T__37=37;

+    public static final int T__38=38;

+    public static final int T__39=39;

+    public static final int RULE_WS=10;

+

+    // delegates

+    // delegators

+

+    public InternalAlfLexer() {;} 

+    public InternalAlfLexer(CharStream input) {

+        this(input, new RecognizerSharedState());

+    }

+    public InternalAlfLexer(CharStream input, RecognizerSharedState state) {

+        super(input,state);

+

+    }

+    public String getGrammarFileName() { return "../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g"; }

+

+    // $ANTLR start "T__12"

+    public final void mT__12() throws RecognitionException {

+        try {

+            int _type = T__12;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11:7: ( '++' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11:9: '++'

+            {

+            match("++"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__12"

+

+    // $ANTLR start "T__13"

+    public final void mT__13() throws RecognitionException {

+        try {

+            int _type = T__13;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12:7: ( '--' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12:9: '--'

+            {

+            match("--"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__13"

+

+    // $ANTLR start "T__14"

+    public final void mT__14() throws RecognitionException {

+        try {

+            int _type = T__14;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13:7: ( '==' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13:9: '=='

+            {

+            match("=="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__14"

+

+    // $ANTLR start "T__15"

+    public final void mT__15() throws RecognitionException {

+        try {

+            int _type = T__15;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14:7: ( '!=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14:9: '!='

+            {

+            match("!="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__15"

+

+    // $ANTLR start "T__16"

+    public final void mT__16() throws RecognitionException {

+        try {

+            int _type = T__16;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15:7: ( 'instanceof' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15:9: 'instanceof'

+            {

+            match("instanceof"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__16"

+

+    // $ANTLR start "T__17"

+    public final void mT__17() throws RecognitionException {

+        try {

+            int _type = T__17;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16:7: ( 'hastype' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16:9: 'hastype'

+            {

+            match("hastype"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__17"

+

+    // $ANTLR start "T__18"

+    public final void mT__18() throws RecognitionException {

+        try {

+            int _type = T__18;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17:7: ( '<' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17:9: '<'

+            {

+            match('<'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__18"

+

+    // $ANTLR start "T__19"

+    public final void mT__19() throws RecognitionException {

+        try {

+            int _type = T__19;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18:7: ( '>' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18:9: '>'

+            {

+            match('>'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__19"

+

+    // $ANTLR start "T__20"

+    public final void mT__20() throws RecognitionException {

+        try {

+            int _type = T__20;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19:7: ( '<=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19:9: '<='

+            {

+            match("<="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__20"

+

+    // $ANTLR start "T__21"

+    public final void mT__21() throws RecognitionException {

+        try {

+            int _type = T__21;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:20:7: ( '>=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:20:9: '>='

+            {

+            match(">="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__21"

+

+    // $ANTLR start "T__22"

+    public final void mT__22() throws RecognitionException {

+        try {

+            int _type = T__22;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:21:7: ( '<<' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:21:9: '<<'

+            {

+            match("<<"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__22"

+

+    // $ANTLR start "T__23"

+    public final void mT__23() throws RecognitionException {

+        try {

+            int _type = T__23;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:22:7: ( '>>' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:22:9: '>>'

+            {

+            match(">>"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__23"

+

+    // $ANTLR start "T__24"

+    public final void mT__24() throws RecognitionException {

+        try {

+            int _type = T__24;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:23:7: ( '>>>' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:23:9: '>>>'

+            {

+            match(">>>"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__24"

+

+    // $ANTLR start "T__25"

+    public final void mT__25() throws RecognitionException {

+        try {

+            int _type = T__25;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:24:7: ( '+' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:24:9: '+'

+            {

+            match('+'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__25"

+

+    // $ANTLR start "T__26"

+    public final void mT__26() throws RecognitionException {

+        try {

+            int _type = T__26;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:25:7: ( '-' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:25:9: '-'

+            {

+            match('-'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__26"

+

+    // $ANTLR start "T__27"

+    public final void mT__27() throws RecognitionException {

+        try {

+            int _type = T__27;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:26:7: ( '*' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:26:9: '*'

+            {

+            match('*'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__27"

+

+    // $ANTLR start "T__28"

+    public final void mT__28() throws RecognitionException {

+        try {

+            int _type = T__28;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:27:7: ( '/' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:27:9: '/'

+            {

+            match('/'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__28"

+

+    // $ANTLR start "T__29"

+    public final void mT__29() throws RecognitionException {

+        try {

+            int _type = T__29;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:28:7: ( '%' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:28:9: '%'

+            {

+            match('%'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__29"

+

+    // $ANTLR start "T__30"

+    public final void mT__30() throws RecognitionException {

+        try {

+            int _type = T__30;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:29:7: ( '!' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:29:9: '!'

+            {

+            match('!'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__30"

+

+    // $ANTLR start "T__31"

+    public final void mT__31() throws RecognitionException {

+        try {

+            int _type = T__31;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:30:7: ( '$' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:30:9: '$'

+            {

+            match('$'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__31"

+

+    // $ANTLR start "T__32"

+    public final void mT__32() throws RecognitionException {

+        try {

+            int _type = T__32;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:31:7: ( '~' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:31:9: '~'

+            {

+            match('~'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__32"

+

+    // $ANTLR start "T__33"

+    public final void mT__33() throws RecognitionException {

+        try {

+            int _type = T__33;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:32:7: ( 'true' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:32:9: 'true'

+            {

+            match("true"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__33"

+

+    // $ANTLR start "T__34"

+    public final void mT__34() throws RecognitionException {

+        try {

+            int _type = T__34;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:33:7: ( 'false' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:33:9: 'false'

+            {

+            match("false"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__34"

+

+    // $ANTLR start "T__35"

+    public final void mT__35() throws RecognitionException {

+        try {

+            int _type = T__35;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:34:7: ( 'createLink' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:34:9: 'createLink'

+            {

+            match("createLink"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__35"

+

+    // $ANTLR start "T__36"

+    public final void mT__36() throws RecognitionException {

+        try {

+            int _type = T__36;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:35:7: ( 'destroyLink' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:35:9: 'destroyLink'

+            {

+            match("destroyLink"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__36"

+

+    // $ANTLR start "T__37"

+    public final void mT__37() throws RecognitionException {

+        try {

+            int _type = T__37;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:36:7: ( 'clearAssoc' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:36:9: 'clearAssoc'

+            {

+            match("clearAssoc"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__37"

+

+    // $ANTLR start "T__38"

+    public final void mT__38() throws RecognitionException {

+        try {

+            int _type = T__38;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:37:7: ( 'select' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:37:9: 'select'

+            {

+            match("select"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__38"

+

+    // $ANTLR start "T__39"

+    public final void mT__39() throws RecognitionException {

+        try {

+            int _type = T__39;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:38:7: ( 'reject' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:38:9: 'reject'

+            {

+            match("reject"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__39"

+

+    // $ANTLR start "T__40"

+    public final void mT__40() throws RecognitionException {

+        try {

+            int _type = T__40;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:39:7: ( 'collect' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:39:9: 'collect'

+            {

+            match("collect"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__40"

+

+    // $ANTLR start "T__41"

+    public final void mT__41() throws RecognitionException {

+        try {

+            int _type = T__41;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:40:7: ( 'iterate' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:40:9: 'iterate'

+            {

+            match("iterate"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__41"

+

+    // $ANTLR start "T__42"

+    public final void mT__42() throws RecognitionException {

+        try {

+            int _type = T__42;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:41:7: ( 'forAll' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:41:9: 'forAll'

+            {

+            match("forAll"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__42"

+

+    // $ANTLR start "T__43"

+    public final void mT__43() throws RecognitionException {

+        try {

+            int _type = T__43;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:42:7: ( 'exists' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:42:9: 'exists'

+            {

+            match("exists"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__43"

+

+    // $ANTLR start "T__44"

+    public final void mT__44() throws RecognitionException {

+        try {

+            int _type = T__44;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:43:7: ( 'one' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:43:9: 'one'

+            {

+            match("one"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__44"

+

+    // $ANTLR start "T__45"

+    public final void mT__45() throws RecognitionException {

+        try {

+            int _type = T__45;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:44:7: ( 'isolated' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:44:9: 'isolated'

+            {

+            match("isolated"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__45"

+

+    // $ANTLR start "T__46"

+    public final void mT__46() throws RecognitionException {

+        try {

+            int _type = T__46;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:45:7: ( 'determined' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:45:9: 'determined'

+            {

+            match("determined"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__46"

+

+    // $ANTLR start "T__47"

+    public final void mT__47() throws RecognitionException {

+        try {

+            int _type = T__47;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:46:7: ( 'assured' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:46:9: 'assured'

+            {

+            match("assured"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__47"

+

+    // $ANTLR start "T__48"

+    public final void mT__48() throws RecognitionException {

+        try {

+            int _type = T__48;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:47:7: ( 'parallel' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:47:9: 'parallel'

+            {

+            match("parallel"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__48"

+

+    // $ANTLR start "T__49"

+    public final void mT__49() throws RecognitionException {

+        try {

+            int _type = T__49;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:48:7: ( '=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:48:9: '='

+            {

+            match('='); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__49"

+

+    // $ANTLR start "T__50"

+    public final void mT__50() throws RecognitionException {

+        try {

+            int _type = T__50;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:49:7: ( '+=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:49:9: '+='

+            {

+            match("+="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__50"

+

+    // $ANTLR start "T__51"

+    public final void mT__51() throws RecognitionException {

+        try {

+            int _type = T__51;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:50:7: ( '-=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:50:9: '-='

+            {

+            match("-="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__51"

+

+    // $ANTLR start "T__52"

+    public final void mT__52() throws RecognitionException {

+        try {

+            int _type = T__52;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:51:7: ( '*=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:51:9: '*='

+            {

+            match("*="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__52"

+

+    // $ANTLR start "T__53"

+    public final void mT__53() throws RecognitionException {

+        try {

+            int _type = T__53;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:52:7: ( '%=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:52:9: '%='

+            {

+            match("%="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__53"

+

+    // $ANTLR start "T__54"

+    public final void mT__54() throws RecognitionException {

+        try {

+            int _type = T__54;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:53:7: ( '/=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:53:9: '/='

+            {

+            match("/="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__54"

+

+    // $ANTLR start "T__55"

+    public final void mT__55() throws RecognitionException {

+        try {

+            int _type = T__55;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:54:7: ( '&=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:54:9: '&='

+            {

+            match("&="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__55"

+

+    // $ANTLR start "T__56"

+    public final void mT__56() throws RecognitionException {

+        try {

+            int _type = T__56;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:55:7: ( '|=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:55:9: '|='

+            {

+            match("|="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__56"

+

+    // $ANTLR start "T__57"

+    public final void mT__57() throws RecognitionException {

+        try {

+            int _type = T__57;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:56:7: ( '^=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:56:9: '^='

+            {

+            match("^="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__57"

+

+    // $ANTLR start "T__58"

+    public final void mT__58() throws RecognitionException {

+        try {

+            int _type = T__58;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:57:7: ( '<<=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:57:9: '<<='

+            {

+            match("<<="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__58"

+

+    // $ANTLR start "T__59"

+    public final void mT__59() throws RecognitionException {

+        try {

+            int _type = T__59;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:58:7: ( '>>=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:58:9: '>>='

+            {

+            match(">>="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__59"

+

+    // $ANTLR start "T__60"

+    public final void mT__60() throws RecognitionException {

+        try {

+            int _type = T__60;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:59:7: ( '>>>=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:59:9: '>>>='

+            {

+            match(">>>="); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__60"

+

+    // $ANTLR start "T__61"

+    public final void mT__61() throws RecognitionException {

+        try {

+            int _type = T__61;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:60:7: ( 'testExpression' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:60:9: 'testExpression'

+            {

+            match("testExpression"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__61"

+

+    // $ANTLR start "T__62"

+    public final void mT__62() throws RecognitionException {

+        try {

+            int _type = T__62;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:61:7: ( 'testAssignmentExpression' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:61:9: 'testAssignmentExpression'

+            {

+            match("testAssignmentExpression"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__62"

+

+    // $ANTLR start "T__63"

+    public final void mT__63() throws RecognitionException {

+        try {

+            int _type = T__63;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:62:7: ( 'testStatement' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:62:9: 'testStatement'

+            {

+            match("testStatement"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__63"

+

+    // $ANTLR start "T__64"

+    public final void mT__64() throws RecognitionException {

+        try {

+            int _type = T__64;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:63:7: ( 'testBlock' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:63:9: 'testBlock'

+            {

+            match("testBlock"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__64"

+

+    // $ANTLR start "T__65"

+    public final void mT__65() throws RecognitionException {

+        try {

+            int _type = T__65;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:64:7: ( '::' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:64:9: '::'

+            {

+            match("::"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__65"

+

+    // $ANTLR start "T__66"

+    public final void mT__66() throws RecognitionException {

+        try {

+            int _type = T__66;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:65:7: ( ',' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:65:9: ','

+            {

+            match(','); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__66"

+

+    // $ANTLR start "T__67"

+    public final void mT__67() throws RecognitionException {

+        try {

+            int _type = T__67;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:66:7: ( '=>' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:66:9: '=>'

+            {

+            match("=>"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__67"

+

+    // $ANTLR start "T__68"

+    public final void mT__68() throws RecognitionException {

+        try {

+            int _type = T__68;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:67:7: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:67:9: '('

+            {

+            match('('); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__68"

+

+    // $ANTLR start "T__69"

+    public final void mT__69() throws RecognitionException {

+        try {

+            int _type = T__69;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:68:7: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:68:9: ')'

+            {

+            match(')'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__69"

+

+    // $ANTLR start "T__70"

+    public final void mT__70() throws RecognitionException {

+        try {

+            int _type = T__70;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:69:7: ( '?' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:69:9: '?'

+            {

+            match('?'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__70"

+

+    // $ANTLR start "T__71"

+    public final void mT__71() throws RecognitionException {

+        try {

+            int _type = T__71;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:70:7: ( ':' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:70:9: ':'

+            {

+            match(':'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__71"

+

+    // $ANTLR start "T__72"

+    public final void mT__72() throws RecognitionException {

+        try {

+            int _type = T__72;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:71:7: ( '||' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:71:9: '||'

+            {

+            match("||"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__72"

+

+    // $ANTLR start "T__73"

+    public final void mT__73() throws RecognitionException {

+        try {

+            int _type = T__73;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:72:7: ( '&&' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:72:9: '&&'

+            {

+            match("&&"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__73"

+

+    // $ANTLR start "T__74"

+    public final void mT__74() throws RecognitionException {

+        try {

+            int _type = T__74;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:73:7: ( '|' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:73:9: '|'

+            {

+            match('|'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__74"

+

+    // $ANTLR start "T__75"

+    public final void mT__75() throws RecognitionException {

+        try {

+            int _type = T__75;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:74:7: ( '^' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:74:9: '^'

+            {

+            match('^'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__75"

+

+    // $ANTLR start "T__76"

+    public final void mT__76() throws RecognitionException {

+        try {

+            int _type = T__76;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:75:7: ( '&' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:75:9: '&'

+            {

+            match('&'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__76"

+

+    // $ANTLR start "T__77"

+    public final void mT__77() throws RecognitionException {

+        try {

+            int _type = T__77;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:76:7: ( '.' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:76:9: '.'

+            {

+            match('.'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__77"

+

+    // $ANTLR start "T__78"

+    public final void mT__78() throws RecognitionException {

+        try {

+            int _type = T__78;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:77:7: ( '[' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:77:9: '['

+            {

+            match('['); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__78"

+

+    // $ANTLR start "T__79"

+    public final void mT__79() throws RecognitionException {

+        try {

+            int _type = T__79;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:78:7: ( ']' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:78:9: ']'

+            {

+            match(']'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__79"

+

+    // $ANTLR start "T__80"

+    public final void mT__80() throws RecognitionException {

+        try {

+            int _type = T__80;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:79:7: ( '->' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:79:9: '->'

+            {

+            match("->"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__80"

+

+    // $ANTLR start "T__81"

+    public final void mT__81() throws RecognitionException {

+        try {

+            int _type = T__81;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:80:7: ( 'reduce' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:80:9: 'reduce'

+            {

+            match("reduce"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__81"

+

+    // $ANTLR start "T__82"

+    public final void mT__82() throws RecognitionException {

+        try {

+            int _type = T__82;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:81:7: ( 'isUnique' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:81:9: 'isUnique'

+            {

+            match("isUnique"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__82"

+

+    // $ANTLR start "T__83"

+    public final void mT__83() throws RecognitionException {

+        try {

+            int _type = T__83;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:82:7: ( 'null' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:82:9: 'null'

+            {

+            match("null"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__83"

+

+    // $ANTLR start "T__84"

+    public final void mT__84() throws RecognitionException {

+        try {

+            int _type = T__84;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:83:7: ( 'this' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:83:9: 'this'

+            {

+            match("this"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__84"

+

+    // $ANTLR start "T__85"

+    public final void mT__85() throws RecognitionException {

+        try {

+            int _type = T__85;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:84:7: ( 'super' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:84:9: 'super'

+            {

+            match("super"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__85"

+

+    // $ANTLR start "T__86"

+    public final void mT__86() throws RecognitionException {

+        try {

+            int _type = T__86;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:85:7: ( 'new' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:85:9: 'new'

+            {

+            match("new"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__86"

+

+    // $ANTLR start "T__87"

+    public final void mT__87() throws RecognitionException {

+        try {

+            int _type = T__87;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:86:7: ( '{' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:86:9: '{'

+            {

+            match('{'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__87"

+

+    // $ANTLR start "T__88"

+    public final void mT__88() throws RecognitionException {

+        try {

+            int _type = T__88;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:87:7: ( '}' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:87:9: '}'

+            {

+            match('}'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__88"

+

+    // $ANTLR start "T__89"

+    public final void mT__89() throws RecognitionException {

+        try {

+            int _type = T__89;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:88:7: ( '..' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:88:9: '..'

+            {

+            match(".."); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__89"

+

+    // $ANTLR start "T__90"

+    public final void mT__90() throws RecognitionException {

+        try {

+            int _type = T__90;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:89:7: ( 'allInstances' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:89:9: 'allInstances'

+            {

+            match("allInstances"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__90"

+

+    // $ANTLR start "T__91"

+    public final void mT__91() throws RecognitionException {

+        try {

+            int _type = T__91;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:90:7: ( '/*@' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:90:9: '/*@'

+            {

+            match("/*@"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__91"

+

+    // $ANTLR start "T__92"

+    public final void mT__92() throws RecognitionException {

+        try {

+            int _type = T__92;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:91:7: ( 'inline' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:91:9: 'inline'

+            {

+            match("inline"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__92"

+

+    // $ANTLR start "T__93"

+    public final void mT__93() throws RecognitionException {

+        try {

+            int _type = T__93;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:92:7: ( '*/' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:92:9: '*/'

+            {

+            match("*/"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__93"

+

+    // $ANTLR start "T__94"

+    public final void mT__94() throws RecognitionException {

+        try {

+            int _type = T__94;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:93:7: ( '//@' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:93:9: '//@'

+            {

+            match("//@"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__94"

+

+    // $ANTLR start "T__95"

+    public final void mT__95() throws RecognitionException {

+        try {

+            int _type = T__95;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:94:7: ( ';' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:94:9: ';'

+            {

+            match(';'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__95"

+

+    // $ANTLR start "T__96"

+    public final void mT__96() throws RecognitionException {

+        try {

+            int _type = T__96;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:95:7: ( 'let' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:95:9: 'let'

+            {

+            match("let"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__96"

+

+    // $ANTLR start "T__97"

+    public final void mT__97() throws RecognitionException {

+        try {

+            int _type = T__97;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:96:7: ( 'if' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:96:9: 'if'

+            {

+            match("if"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__97"

+

+    // $ANTLR start "T__98"

+    public final void mT__98() throws RecognitionException {

+        try {

+            int _type = T__98;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:97:7: ( 'else' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:97:9: 'else'

+            {

+            match("else"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__98"

+

+    // $ANTLR start "T__99"

+    public final void mT__99() throws RecognitionException {

+        try {

+            int _type = T__99;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:98:7: ( 'or' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:98:9: 'or'

+            {

+            match("or"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__99"

+

+    // $ANTLR start "T__100"

+    public final void mT__100() throws RecognitionException {

+        try {

+            int _type = T__100;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:99:8: ( 'switch' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:99:10: 'switch'

+            {

+            match("switch"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__100"

+

+    // $ANTLR start "T__101"

+    public final void mT__101() throws RecognitionException {

+        try {

+            int _type = T__101;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:100:8: ( 'case' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:100:10: 'case'

+            {

+            match("case"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__101"

+

+    // $ANTLR start "T__102"

+    public final void mT__102() throws RecognitionException {

+        try {

+            int _type = T__102;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:101:8: ( 'default' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:101:10: 'default'

+            {

+            match("default"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__102"

+

+    // $ANTLR start "T__103"

+    public final void mT__103() throws RecognitionException {

+        try {

+            int _type = T__103;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:102:8: ( 'while' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:102:10: 'while'

+            {

+            match("while"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__103"

+

+    // $ANTLR start "T__104"

+    public final void mT__104() throws RecognitionException {

+        try {

+            int _type = T__104;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:103:8: ( 'do' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:103:10: 'do'

+            {

+            match("do"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__104"

+

+    // $ANTLR start "T__105"

+    public final void mT__105() throws RecognitionException {

+        try {

+            int _type = T__105;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:104:8: ( 'for' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:104:10: 'for'

+            {

+            match("for"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__105"

+

+    // $ANTLR start "T__106"

+    public final void mT__106() throws RecognitionException {

+        try {

+            int _type = T__106;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:105:8: ( 'in' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:105:10: 'in'

+            {

+            match("in"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__106"

+

+    // $ANTLR start "T__107"

+    public final void mT__107() throws RecognitionException {

+        try {

+            int _type = T__107;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:106:8: ( 'break' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:106:10: 'break'

+            {

+            match("break"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__107"

+

+    // $ANTLR start "T__108"

+    public final void mT__108() throws RecognitionException {

+        try {

+            int _type = T__108;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:107:8: ( 'return' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:107:10: 'return'

+            {

+            match("return"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__108"

+

+    // $ANTLR start "T__109"

+    public final void mT__109() throws RecognitionException {

+        try {

+            int _type = T__109;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:108:8: ( 'accept' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:108:10: 'accept'

+            {

+            match("accept"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__109"

+

+    // $ANTLR start "T__110"

+    public final void mT__110() throws RecognitionException {

+        try {

+            int _type = T__110;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:109:8: ( 'classify' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:109:10: 'classify'

+            {

+            match("classify"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__110"

+

+    // $ANTLR start "T__111"

+    public final void mT__111() throws RecognitionException {

+        try {

+            int _type = T__111;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:110:8: ( 'from' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:110:10: 'from'

+            {

+            match("from"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__111"

+

+    // $ANTLR start "T__112"

+    public final void mT__112() throws RecognitionException {

+        try {

+            int _type = T__112;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:111:8: ( 'to' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:111:10: 'to'

+            {

+            match("to"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__112"

+

+    // $ANTLR start "T__113"

+    public final void mT__113() throws RecognitionException {

+        try {

+            int _type = T__113;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:112:8: ( 'ordered' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:112:10: 'ordered'

+            {

+            match("ordered"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "T__113"

+

+    // $ANTLR start "RULE_INTEGERVALUE"

+    public final void mRULE_INTEGERVALUE() throws RecognitionException {

+        try {

+            int _type = RULE_INTEGERVALUE;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:19: ( ( ( '0' | '1' .. '9' ( ( '_' )? '0' .. '9' )* ) | ( '0b' | '0B' ) '0' .. '1' ( ( '_' )? '0' .. '1' )* | ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) ( ( '_' )? ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )* | '0' ( '_' )? '0' .. '7' ( ( '_' )? '0' .. '7' )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:21: ( ( '0' | '1' .. '9' ( ( '_' )? '0' .. '9' )* ) | ( '0b' | '0B' ) '0' .. '1' ( ( '_' )? '0' .. '1' )* | ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) ( ( '_' )? ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )* | '0' ( '_' )? '0' .. '7' ( ( '_' )? '0' .. '7' )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:21: ( ( '0' | '1' .. '9' ( ( '_' )? '0' .. '9' )* ) | ( '0b' | '0B' ) '0' .. '1' ( ( '_' )? '0' .. '1' )* | ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) ( ( '_' )? ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )* | '0' ( '_' )? '0' .. '7' ( ( '_' )? '0' .. '7' )* )

+            int alt13=4;

+            int LA13_0 = input.LA(1);

+

+            if ( (LA13_0=='0') ) {

+                switch ( input.LA(2) ) {

+                case 'B':

+                case 'b':

+                    {

+                    alt13=2;

+                    }

+                    break;

+                case 'X':

+                case 'x':

+                    {

+                    alt13=3;

+                    }

+                    break;

+                case '0':

+                case '1':

+                case '2':

+                case '3':

+                case '4':

+                case '5':

+                case '6':

+                case '7':

+                case '_':

+                    {

+                    alt13=4;

+                    }

+                    break;

+                default:

+                    alt13=1;}

+

+            }

+            else if ( ((LA13_0>='1' && LA13_0<='9')) ) {

+                alt13=1;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 13, 0, input);

+

+                throw nvae;

+            }

+            switch (alt13) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:22: ( '0' | '1' .. '9' ( ( '_' )? '0' .. '9' )* )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:22: ( '0' | '1' .. '9' ( ( '_' )? '0' .. '9' )* )

+                    int alt3=2;

+                    int LA3_0 = input.LA(1);

+

+                    if ( (LA3_0=='0') ) {

+                        alt3=1;

+                    }

+                    else if ( ((LA3_0>='1' && LA3_0<='9')) ) {

+                        alt3=2;

+                    }

+                    else {

+                        NoViableAltException nvae =

+                            new NoViableAltException("", 3, 0, input);

+

+                        throw nvae;

+                    }

+                    switch (alt3) {

+                        case 1 :

+                            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:23: '0'

+                            {

+                            match('0'); 

+

+                            }

+                            break;

+                        case 2 :

+                            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:27: '1' .. '9' ( ( '_' )? '0' .. '9' )*

+                            {

+                            matchRange('1','9'); 

+                            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:36: ( ( '_' )? '0' .. '9' )*

+                            loop2:

+                            do {

+                                int alt2=2;

+                                int LA2_0 = input.LA(1);

+

+                                if ( ((LA2_0>='0' && LA2_0<='9')||LA2_0=='_') ) {

+                                    alt2=1;

+                                }

+

+

+                                switch (alt2) {

+                            	case 1 :

+                            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:37: ( '_' )? '0' .. '9'

+                            	    {

+                            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:37: ( '_' )?

+                            	    int alt1=2;

+                            	    int LA1_0 = input.LA(1);

+

+                            	    if ( (LA1_0=='_') ) {

+                            	        alt1=1;

+                            	    }

+                            	    switch (alt1) {

+                            	        case 1 :

+                            	            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:37: '_'

+                            	            {

+                            	            match('_'); 

+

+                            	            }

+                            	            break;

+

+                            	    }

+

+                            	    matchRange('0','9'); 

+

+                            	    }

+                            	    break;

+

+                            	default :

+                            	    break loop2;

+                                }

+                            } while (true);

+

+

+                            }

+                            break;

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:54: ( '0b' | '0B' ) '0' .. '1' ( ( '_' )? '0' .. '1' )*

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:54: ( '0b' | '0B' )

+                    int alt4=2;

+                    int LA4_0 = input.LA(1);

+

+                    if ( (LA4_0=='0') ) {

+                        int LA4_1 = input.LA(2);

+

+                        if ( (LA4_1=='b') ) {

+                            alt4=1;

+                        }

+                        else if ( (LA4_1=='B') ) {

+                            alt4=2;

+                        }

+                        else {

+                            NoViableAltException nvae =

+                                new NoViableAltException("", 4, 1, input);

+

+                            throw nvae;

+                        }

+                    }

+                    else {

+                        NoViableAltException nvae =

+                            new NoViableAltException("", 4, 0, input);

+

+                        throw nvae;

+                    }

+                    switch (alt4) {

+                        case 1 :

+                            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:55: '0b'

+                            {

+                            match("0b"); 

+

+

+                            }

+                            break;

+                        case 2 :

+                            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:60: '0B'

+                            {

+                            match("0B"); 

+

+

+                            }

+                            break;

+

+                    }

+

+                    matchRange('0','1'); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:75: ( ( '_' )? '0' .. '1' )*

+                    loop6:

+                    do {

+                        int alt6=2;

+                        int LA6_0 = input.LA(1);

+

+                        if ( ((LA6_0>='0' && LA6_0<='1')||LA6_0=='_') ) {

+                            alt6=1;

+                        }

+

+

+                        switch (alt6) {

+                    	case 1 :

+                    	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:76: ( '_' )? '0' .. '1'

+                    	    {

+                    	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:76: ( '_' )?

+                    	    int alt5=2;

+                    	    int LA5_0 = input.LA(1);

+

+                    	    if ( (LA5_0=='_') ) {

+                    	        alt5=1;

+                    	    }

+                    	    switch (alt5) {

+                    	        case 1 :

+                    	            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:76: '_'

+                    	            {

+                    	            match('_'); 

+

+                    	            }

+                    	            break;

+

+                    	    }

+

+                    	    matchRange('0','1'); 

+

+                    	    }

+                    	    break;

+

+                    	default :

+                    	    break loop6;

+                        }

+                    } while (true);

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:92: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) ( ( '_' )? ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )*

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:92: ( '0x' | '0X' )

+                    int alt7=2;

+                    int LA7_0 = input.LA(1);

+

+                    if ( (LA7_0=='0') ) {

+                        int LA7_1 = input.LA(2);

+

+                        if ( (LA7_1=='x') ) {

+                            alt7=1;

+                        }

+                        else if ( (LA7_1=='X') ) {

+                            alt7=2;

+                        }

+                        else {

+                            NoViableAltException nvae =

+                                new NoViableAltException("", 7, 1, input);

+

+                            throw nvae;

+                        }

+                    }

+                    else {

+                        NoViableAltException nvae =

+                            new NoViableAltException("", 7, 0, input);

+

+                        throw nvae;

+                    }

+                    switch (alt7) {

+                        case 1 :

+                            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:93: '0x'

+                            {

+                            match("0x"); 

+

+

+                            }

+                            break;

+                        case 2 :

+                            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:98: '0X'

+                            {

+                            match("0X"); 

+

+

+                            }

+                            break;

+

+                    }

+

+                    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {

+                        input.consume();

+

+                    }

+                    else {

+                        MismatchedSetException mse = new MismatchedSetException(null,input);

+                        recover(mse);

+                        throw mse;}

+

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:133: ( ( '_' )? ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )*

+                    loop9:

+                    do {

+                        int alt9=2;

+                        int LA9_0 = input.LA(1);

+

+                        if ( ((LA9_0>='0' && LA9_0<='9')||(LA9_0>='A' && LA9_0<='F')||LA9_0=='_'||(LA9_0>='a' && LA9_0<='f')) ) {

+                            alt9=1;

+                        }

+

+

+                        switch (alt9) {

+                    	case 1 :

+                    	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:134: ( '_' )? ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )

+                    	    {

+                    	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:134: ( '_' )?

+                    	    int alt8=2;

+                    	    int LA8_0 = input.LA(1);

+

+                    	    if ( (LA8_0=='_') ) {

+                    	        alt8=1;

+                    	    }

+                    	    switch (alt8) {

+                    	        case 1 :

+                    	            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:134: '_'

+                    	            {

+                    	            match('_'); 

+

+                    	            }

+                    	            break;

+

+                    	    }

+

+                    	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {

+                    	        input.consume();

+

+                    	    }

+                    	    else {

+                    	        MismatchedSetException mse = new MismatchedSetException(null,input);

+                    	        recover(mse);

+                    	        throw mse;}

+

+

+                    	    }

+                    	    break;

+

+                    	default :

+                    	    break loop9;

+                        }

+                    } while (true);

+

+

+                    }

+                    break;

+                case 4 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:170: '0' ( '_' )? '0' .. '7' ( ( '_' )? '0' .. '7' )*

+                    {

+                    match('0'); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:174: ( '_' )?

+                    int alt10=2;

+                    int LA10_0 = input.LA(1);

+

+                    if ( (LA10_0=='_') ) {

+                        alt10=1;

+                    }

+                    switch (alt10) {

+                        case 1 :

+                            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:174: '_'

+                            {

+                            match('_'); 

+

+                            }

+                            break;

+

+                    }

+

+                    matchRange('0','7'); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:188: ( ( '_' )? '0' .. '7' )*

+                    loop12:

+                    do {

+                        int alt12=2;

+                        int LA12_0 = input.LA(1);

+

+                        if ( ((LA12_0>='0' && LA12_0<='7')||LA12_0=='_') ) {

+                            alt12=1;

+                        }

+

+

+                        switch (alt12) {

+                    	case 1 :

+                    	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:189: ( '_' )? '0' .. '7'

+                    	    {

+                    	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:189: ( '_' )?

+                    	    int alt11=2;

+                    	    int LA11_0 = input.LA(1);

+

+                    	    if ( (LA11_0=='_') ) {

+                    	        alt11=1;

+                    	    }

+                    	    switch (alt11) {

+                    	        case 1 :

+                    	            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19036:189: '_'

+                    	            {

+                    	            match('_'); 

+

+                    	            }

+                    	            break;

+

+                    	    }

+

+                    	    matchRange('0','7'); 

+

+                    	    }

+                    	    break;

+

+                    	default :

+                    	    break loop12;

+                        }

+                    } while (true);

+

+

+                    }

+                    break;

+

+            }

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "RULE_INTEGERVALUE"

+

+    // $ANTLR start "RULE_ID"

+    public final void mRULE_ID() throws RecognitionException {

+        try {

+            int _type = RULE_ID;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19038:9: ( ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | '\\'' ( options {greedy=false; } : . )* '\\'' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19038:11: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | '\\'' ( options {greedy=false; } : . )* '\\'' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19038:11: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* | '\\'' ( options {greedy=false; } : . )* '\\'' )

+            int alt16=2;

+            int LA16_0 = input.LA(1);

+

+            if ( ((LA16_0>='A' && LA16_0<='Z')||LA16_0=='_'||(LA16_0>='a' && LA16_0<='z')) ) {

+                alt16=1;

+            }

+            else if ( (LA16_0=='\'') ) {

+                alt16=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 16, 0, input);

+

+                throw nvae;

+            }

+            switch (alt16) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19038:12: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*

+                    {

+                    if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {

+                        input.consume();

+

+                    }

+                    else {

+                        MismatchedSetException mse = new MismatchedSetException(null,input);

+                        recover(mse);

+                        throw mse;}

+

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19038:36: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*

+                    loop14:

+                    do {

+                        int alt14=2;

+                        int LA14_0 = input.LA(1);

+

+                        if ( ((LA14_0>='0' && LA14_0<='9')||(LA14_0>='A' && LA14_0<='Z')||LA14_0=='_'||(LA14_0>='a' && LA14_0<='z')) ) {

+                            alt14=1;

+                        }

+

+

+                        switch (alt14) {

+                    	case 1 :

+                    	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:

+                    	    {

+                    	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {

+                    	        input.consume();

+

+                    	    }

+                    	    else {

+                    	        MismatchedSetException mse = new MismatchedSetException(null,input);

+                    	        recover(mse);

+                    	        throw mse;}

+

+

+                    	    }

+                    	    break;

+

+                    	default :

+                    	    break loop14;

+                        }

+                    } while (true);

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19038:70: '\\'' ( options {greedy=false; } : . )* '\\''

+                    {

+                    match('\''); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19038:75: ( options {greedy=false; } : . )*

+                    loop15:

+                    do {

+                        int alt15=2;

+                        int LA15_0 = input.LA(1);

+

+                        if ( (LA15_0=='\'') ) {

+                            alt15=2;

+                        }

+                        else if ( ((LA15_0>='\u0000' && LA15_0<='&')||(LA15_0>='(' && LA15_0<='\uFFFF')) ) {

+                            alt15=1;

+                        }

+

+

+                        switch (alt15) {

+                    	case 1 :

+                    	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19038:103: .

+                    	    {

+                    	    matchAny(); 

+

+                    	    }

+                    	    break;

+

+                    	default :

+                    	    break loop15;

+                        }

+                    } while (true);

+

+                    match('\''); 

+

+                    }

+                    break;

+

+            }

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "RULE_ID"

+

+    // $ANTLR start "RULE_STRING"

+    public final void mRULE_STRING() throws RecognitionException {

+        try {

+            int _type = RULE_STRING;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19040:13: ( '\"' ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* '\"' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19040:15: '\"' ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* '\"'

+            {

+            match('\"'); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19040:19: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )*

+            loop17:

+            do {

+                int alt17=3;

+                int LA17_0 = input.LA(1);

+

+                if ( (LA17_0=='\\') ) {

+                    alt17=1;

+                }

+                else if ( ((LA17_0>='\u0000' && LA17_0<='!')||(LA17_0>='#' && LA17_0<='[')||(LA17_0>=']' && LA17_0<='\uFFFF')) ) {

+                    alt17=2;

+                }

+

+

+                switch (alt17) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19040:20: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\"' | '\\'' | '\\\\' )

+            	    {

+            	    match('\\'); 

+            	    if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||input.LA(1)=='t' ) {

+            	        input.consume();

+

+            	    }

+            	    else {

+            	        MismatchedSetException mse = new MismatchedSetException(null,input);

+            	        recover(mse);

+            	        throw mse;}

+

+

+            	    }

+            	    break;

+            	case 2 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19040:61: ~ ( ( '\\\\' | '\"' ) )

+            	    {

+            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {

+            	        input.consume();

+

+            	    }

+            	    else {

+            	        MismatchedSetException mse = new MismatchedSetException(null,input);

+            	        recover(mse);

+            	        throw mse;}

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop17;

+                }

+            } while (true);

+

+            match('\"'); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "RULE_STRING"

+

+    // $ANTLR start "RULE_ML_COMMENT"

+    public final void mRULE_ML_COMMENT() throws RecognitionException {

+        try {

+            int _type = RULE_ML_COMMENT;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19042:17: ( '/*' ~ ( '@' ) ( options {greedy=false; } : . )* '*/' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19042:19: '/*' ~ ( '@' ) ( options {greedy=false; } : . )* '*/'

+            {

+            match("/*"); 

+

+            if ( (input.LA(1)>='\u0000' && input.LA(1)<='?')||(input.LA(1)>='A' && input.LA(1)<='\uFFFF') ) {

+                input.consume();

+

+            }

+            else {

+                MismatchedSetException mse = new MismatchedSetException(null,input);

+                recover(mse);

+                throw mse;}

+

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19042:31: ( options {greedy=false; } : . )*

+            loop18:

+            do {

+                int alt18=2;

+                int LA18_0 = input.LA(1);

+

+                if ( (LA18_0=='*') ) {

+                    int LA18_1 = input.LA(2);

+

+                    if ( (LA18_1=='/') ) {

+                        alt18=2;

+                    }

+                    else if ( ((LA18_1>='\u0000' && LA18_1<='.')||(LA18_1>='0' && LA18_1<='\uFFFF')) ) {

+                        alt18=1;

+                    }

+

+

+                }

+                else if ( ((LA18_0>='\u0000' && LA18_0<=')')||(LA18_0>='+' && LA18_0<='\uFFFF')) ) {

+                    alt18=1;

+                }

+

+

+                switch (alt18) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19042:59: .

+            	    {

+            	    matchAny(); 

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop18;

+                }

+            } while (true);

+

+            match("*/"); 

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "RULE_ML_COMMENT"

+

+    // $ANTLR start "RULE_SL_COMMENT"

+    public final void mRULE_SL_COMMENT() throws RecognitionException {

+        try {

+            int _type = RULE_SL_COMMENT;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19044:17: ( '//' (~ ( ( '\\n' | '\\r' | '@' ) ) )* ( ( '\\r' )? '\\n' )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19044:19: '//' (~ ( ( '\\n' | '\\r' | '@' ) ) )* ( ( '\\r' )? '\\n' )?

+            {

+            match("//"); 

+

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19044:24: (~ ( ( '\\n' | '\\r' | '@' ) ) )*

+            loop19:

+            do {

+                int alt19=2;

+                int LA19_0 = input.LA(1);

+

+                if ( ((LA19_0>='\u0000' && LA19_0<='\t')||(LA19_0>='\u000B' && LA19_0<='\f')||(LA19_0>='\u000E' && LA19_0<='?')||(LA19_0>='A' && LA19_0<='\uFFFF')) ) {

+                    alt19=1;

+                }

+

+

+                switch (alt19) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19044:24: ~ ( ( '\\n' | '\\r' | '@' ) )

+            	    {

+            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='?')||(input.LA(1)>='A' && input.LA(1)<='\uFFFF') ) {

+            	        input.consume();

+

+            	    }

+            	    else {

+            	        MismatchedSetException mse = new MismatchedSetException(null,input);

+            	        recover(mse);

+            	        throw mse;}

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop19;

+                }

+            } while (true);

+

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19044:44: ( ( '\\r' )? '\\n' )?

+            int alt21=2;

+            int LA21_0 = input.LA(1);

+

+            if ( (LA21_0=='\n'||LA21_0=='\r') ) {

+                alt21=1;

+            }

+            switch (alt21) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19044:45: ( '\\r' )? '\\n'

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19044:45: ( '\\r' )?

+                    int alt20=2;

+                    int LA20_0 = input.LA(1);

+

+                    if ( (LA20_0=='\r') ) {

+                        alt20=1;

+                    }

+                    switch (alt20) {

+                        case 1 :

+                            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19044:45: '\\r'

+                            {

+                            match('\r'); 

+

+                            }

+                            break;

+

+                    }

+

+                    match('\n'); 

+

+                    }

+                    break;

+

+            }

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "RULE_SL_COMMENT"

+

+    // $ANTLR start "RULE_INT"

+    public final void mRULE_INT() throws RecognitionException {

+        try {

+            int _type = RULE_INT;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19046:10: ( ( '0' .. '9' )+ )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19046:12: ( '0' .. '9' )+

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19046:12: ( '0' .. '9' )+

+            int cnt22=0;

+            loop22:

+            do {

+                int alt22=2;

+                int LA22_0 = input.LA(1);

+

+                if ( ((LA22_0>='0' && LA22_0<='9')) ) {

+                    alt22=1;

+                }

+

+

+                switch (alt22) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19046:13: '0' .. '9'

+            	    {

+            	    matchRange('0','9'); 

+

+            	    }

+            	    break;

+

+            	default :

+            	    if ( cnt22 >= 1 ) break loop22;

+                        EarlyExitException eee =

+                            new EarlyExitException(22, input);

+                        throw eee;

+                }

+                cnt22++;

+            } while (true);

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "RULE_INT"

+

+    // $ANTLR start "RULE_WS"

+    public final void mRULE_WS() throws RecognitionException {

+        try {

+            int _type = RULE_WS;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19048:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19048:11: ( ' ' | '\\t' | '\\r' | '\\n' )+

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19048:11: ( ' ' | '\\t' | '\\r' | '\\n' )+

+            int cnt23=0;

+            loop23:

+            do {

+                int alt23=2;

+                int LA23_0 = input.LA(1);

+

+                if ( ((LA23_0>='\t' && LA23_0<='\n')||LA23_0=='\r'||LA23_0==' ') ) {

+                    alt23=1;

+                }

+

+

+                switch (alt23) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:

+            	    {

+            	    if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {

+            	        input.consume();

+

+            	    }

+            	    else {

+            	        MismatchedSetException mse = new MismatchedSetException(null,input);

+            	        recover(mse);

+            	        throw mse;}

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    if ( cnt23 >= 1 ) break loop23;

+                        EarlyExitException eee =

+                            new EarlyExitException(23, input);

+                        throw eee;

+                }

+                cnt23++;

+            } while (true);

+

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "RULE_WS"

+

+    // $ANTLR start "RULE_ANY_OTHER"

+    public final void mRULE_ANY_OTHER() throws RecognitionException {

+        try {

+            int _type = RULE_ANY_OTHER;

+            int _channel = DEFAULT_TOKEN_CHANNEL;

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19050:16: ( . )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19050:18: .

+            {

+            matchAny(); 

+

+            }

+

+            state.type = _type;

+            state.channel = _channel;

+        }

+        finally {

+        }

+    }

+    // $ANTLR end "RULE_ANY_OTHER"

+

+    public void mTokens() throws RecognitionException {

+        // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:8: ( T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | T__113 | RULE_INTEGERVALUE | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_INT | RULE_WS | RULE_ANY_OTHER )

+        int alt24=110;

+        alt24 = dfa24.predict(input);

+        switch (alt24) {

+            case 1 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:10: T__12

+                {

+                mT__12(); 

+

+                }

+                break;

+            case 2 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:16: T__13

+                {

+                mT__13(); 

+

+                }

+                break;

+            case 3 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:22: T__14

+                {

+                mT__14(); 

+

+                }

+                break;

+            case 4 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:28: T__15

+                {

+                mT__15(); 

+

+                }

+                break;

+            case 5 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:34: T__16

+                {

+                mT__16(); 

+

+                }

+                break;

+            case 6 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:40: T__17

+                {

+                mT__17(); 

+

+                }

+                break;

+            case 7 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:46: T__18

+                {

+                mT__18(); 

+

+                }

+                break;

+            case 8 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:52: T__19

+                {

+                mT__19(); 

+

+                }

+                break;

+            case 9 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:58: T__20

+                {

+                mT__20(); 

+

+                }

+                break;

+            case 10 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:64: T__21

+                {

+                mT__21(); 

+

+                }

+                break;

+            case 11 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:70: T__22

+                {

+                mT__22(); 

+

+                }

+                break;

+            case 12 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:76: T__23

+                {

+                mT__23(); 

+

+                }

+                break;

+            case 13 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:82: T__24

+                {

+                mT__24(); 

+

+                }

+                break;

+            case 14 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:88: T__25

+                {

+                mT__25(); 

+

+                }

+                break;

+            case 15 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:94: T__26

+                {

+                mT__26(); 

+

+                }

+                break;

+            case 16 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:100: T__27

+                {

+                mT__27(); 

+

+                }

+                break;

+            case 17 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:106: T__28

+                {

+                mT__28(); 

+

+                }

+                break;

+            case 18 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:112: T__29

+                {

+                mT__29(); 

+

+                }

+                break;

+            case 19 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:118: T__30

+                {

+                mT__30(); 

+

+                }

+                break;

+            case 20 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:124: T__31

+                {

+                mT__31(); 

+

+                }

+                break;

+            case 21 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:130: T__32

+                {

+                mT__32(); 

+

+                }

+                break;

+            case 22 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:136: T__33

+                {

+                mT__33(); 

+

+                }

+                break;

+            case 23 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:142: T__34

+                {

+                mT__34(); 

+

+                }

+                break;

+            case 24 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:148: T__35

+                {

+                mT__35(); 

+

+                }

+                break;

+            case 25 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:154: T__36

+                {

+                mT__36(); 

+

+                }

+                break;

+            case 26 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:160: T__37

+                {

+                mT__37(); 

+

+                }

+                break;

+            case 27 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:166: T__38

+                {

+                mT__38(); 

+

+                }

+                break;

+            case 28 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:172: T__39

+                {

+                mT__39(); 

+

+                }

+                break;

+            case 29 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:178: T__40

+                {

+                mT__40(); 

+

+                }

+                break;

+            case 30 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:184: T__41

+                {

+                mT__41(); 

+

+                }

+                break;

+            case 31 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:190: T__42

+                {

+                mT__42(); 

+

+                }

+                break;

+            case 32 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:196: T__43

+                {

+                mT__43(); 

+

+                }

+                break;

+            case 33 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:202: T__44

+                {

+                mT__44(); 

+

+                }

+                break;

+            case 34 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:208: T__45

+                {

+                mT__45(); 

+

+                }

+                break;

+            case 35 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:214: T__46

+                {

+                mT__46(); 

+

+                }

+                break;

+            case 36 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:220: T__47

+                {

+                mT__47(); 

+

+                }

+                break;

+            case 37 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:226: T__48

+                {

+                mT__48(); 

+

+                }

+                break;

+            case 38 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:232: T__49

+                {

+                mT__49(); 

+

+                }

+                break;

+            case 39 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:238: T__50

+                {

+                mT__50(); 

+

+                }

+                break;

+            case 40 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:244: T__51

+                {

+                mT__51(); 

+

+                }

+                break;

+            case 41 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:250: T__52

+                {

+                mT__52(); 

+

+                }

+                break;

+            case 42 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:256: T__53

+                {

+                mT__53(); 

+

+                }

+                break;

+            case 43 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:262: T__54

+                {

+                mT__54(); 

+

+                }

+                break;

+            case 44 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:268: T__55

+                {

+                mT__55(); 

+

+                }

+                break;

+            case 45 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:274: T__56

+                {

+                mT__56(); 

+

+                }

+                break;

+            case 46 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:280: T__57

+                {

+                mT__57(); 

+

+                }

+                break;

+            case 47 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:286: T__58

+                {

+                mT__58(); 

+

+                }

+                break;

+            case 48 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:292: T__59

+                {

+                mT__59(); 

+

+                }

+                break;

+            case 49 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:298: T__60

+                {

+                mT__60(); 

+

+                }

+                break;

+            case 50 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:304: T__61

+                {

+                mT__61(); 

+

+                }

+                break;

+            case 51 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:310: T__62

+                {

+                mT__62(); 

+

+                }

+                break;

+            case 52 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:316: T__63

+                {

+                mT__63(); 

+

+                }

+                break;

+            case 53 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:322: T__64

+                {

+                mT__64(); 

+

+                }

+                break;

+            case 54 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:328: T__65

+                {

+                mT__65(); 

+

+                }

+                break;

+            case 55 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:334: T__66

+                {

+                mT__66(); 

+

+                }

+                break;

+            case 56 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:340: T__67

+                {

+                mT__67(); 

+

+                }

+                break;

+            case 57 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:346: T__68

+                {

+                mT__68(); 

+

+                }

+                break;

+            case 58 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:352: T__69

+                {

+                mT__69(); 

+

+                }

+                break;

+            case 59 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:358: T__70

+                {

+                mT__70(); 

+

+                }

+                break;

+            case 60 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:364: T__71

+                {

+                mT__71(); 

+

+                }

+                break;

+            case 61 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:370: T__72

+                {

+                mT__72(); 

+

+                }

+                break;

+            case 62 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:376: T__73

+                {

+                mT__73(); 

+

+                }

+                break;

+            case 63 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:382: T__74

+                {

+                mT__74(); 

+

+                }

+                break;

+            case 64 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:388: T__75

+                {

+                mT__75(); 

+

+                }

+                break;

+            case 65 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:394: T__76

+                {

+                mT__76(); 

+

+                }

+                break;

+            case 66 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:400: T__77

+                {

+                mT__77(); 

+

+                }

+                break;

+            case 67 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:406: T__78

+                {

+                mT__78(); 

+

+                }

+                break;

+            case 68 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:412: T__79

+                {

+                mT__79(); 

+

+                }

+                break;

+            case 69 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:418: T__80

+                {

+                mT__80(); 

+

+                }

+                break;

+            case 70 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:424: T__81

+                {

+                mT__81(); 

+

+                }

+                break;

+            case 71 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:430: T__82

+                {

+                mT__82(); 

+

+                }

+                break;

+            case 72 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:436: T__83

+                {

+                mT__83(); 

+

+                }

+                break;

+            case 73 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:442: T__84

+                {

+                mT__84(); 

+

+                }

+                break;

+            case 74 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:448: T__85

+                {

+                mT__85(); 

+

+                }

+                break;

+            case 75 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:454: T__86

+                {

+                mT__86(); 

+

+                }

+                break;

+            case 76 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:460: T__87

+                {

+                mT__87(); 

+

+                }

+                break;

+            case 77 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:466: T__88

+                {

+                mT__88(); 

+

+                }

+                break;

+            case 78 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:472: T__89

+                {

+                mT__89(); 

+

+                }

+                break;

+            case 79 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:478: T__90

+                {

+                mT__90(); 

+

+                }

+                break;

+            case 80 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:484: T__91

+                {

+                mT__91(); 

+

+                }

+                break;

+            case 81 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:490: T__92

+                {

+                mT__92(); 

+

+                }

+                break;

+            case 82 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:496: T__93

+                {

+                mT__93(); 

+

+                }

+                break;

+            case 83 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:502: T__94

+                {

+                mT__94(); 

+

+                }

+                break;

+            case 84 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:508: T__95

+                {

+                mT__95(); 

+

+                }

+                break;

+            case 85 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:514: T__96

+                {

+                mT__96(); 

+

+                }

+                break;

+            case 86 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:520: T__97

+                {

+                mT__97(); 

+

+                }

+                break;

+            case 87 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:526: T__98

+                {

+                mT__98(); 

+

+                }

+                break;

+            case 88 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:532: T__99

+                {

+                mT__99(); 

+

+                }

+                break;

+            case 89 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:538: T__100

+                {

+                mT__100(); 

+

+                }

+                break;

+            case 90 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:545: T__101

+                {

+                mT__101(); 

+

+                }

+                break;

+            case 91 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:552: T__102

+                {

+                mT__102(); 

+

+                }

+                break;

+            case 92 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:559: T__103

+                {

+                mT__103(); 

+

+                }

+                break;

+            case 93 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:566: T__104

+                {

+                mT__104(); 

+

+                }

+                break;

+            case 94 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:573: T__105

+                {

+                mT__105(); 

+

+                }

+                break;

+            case 95 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:580: T__106

+                {

+                mT__106(); 

+

+                }

+                break;

+            case 96 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:587: T__107

+                {

+                mT__107(); 

+

+                }

+                break;

+            case 97 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:594: T__108

+                {

+                mT__108(); 

+

+                }

+                break;

+            case 98 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:601: T__109

+                {

+                mT__109(); 

+

+                }

+                break;

+            case 99 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:608: T__110

+                {

+                mT__110(); 

+

+                }

+                break;

+            case 100 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:615: T__111

+                {

+                mT__111(); 

+

+                }

+                break;

+            case 101 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:622: T__112

+                {

+                mT__112(); 

+

+                }

+                break;

+            case 102 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:629: T__113

+                {

+                mT__113(); 

+

+                }

+                break;

+            case 103 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:636: RULE_INTEGERVALUE

+                {

+                mRULE_INTEGERVALUE(); 

+

+                }

+                break;

+            case 104 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:654: RULE_ID

+                {

+                mRULE_ID(); 

+

+                }

+                break;

+            case 105 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:662: RULE_STRING

+                {

+                mRULE_STRING(); 

+

+                }

+                break;

+            case 106 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:674: RULE_ML_COMMENT

+                {

+                mRULE_ML_COMMENT(); 

+

+                }

+                break;

+            case 107 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:690: RULE_SL_COMMENT

+                {

+                mRULE_SL_COMMENT(); 

+

+                }

+                break;

+            case 108 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:706: RULE_INT

+                {

+                mRULE_INT(); 

+

+                }

+                break;

+            case 109 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:715: RULE_WS

+                {

+                mRULE_WS(); 

+

+                }

+                break;

+            case 110 :

+                // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1:723: RULE_ANY_OTHER

+                {

+                mRULE_ANY_OTHER(); 

+

+                }

+                break;

+

+        }

+

+    }

+

+

+    protected DFA24 dfa24 = new DFA24(this);

+    static final String DFA24_eotS =

+        "\1\uffff\1\63\1\67\1\72\1\74\2\101\1\105\1\110\1\113\1\117\1\121"+

+        "\2\uffff\12\101\1\157\1\162\1\164\1\166\4\uffff\1\174\2\uffff\1"+

+        "\101\3\uffff\3\101\2\u0087\1\uffff\2\60\16\uffff\1\u008f\2\101\1"+

+        "\u0093\1\uffff\1\101\1\uffff\1\u0096\2\uffff\1\u0099\6\uffff\1\u009d"+

+        "\5\uffff\3\101\1\u00a1\10\101\1\u00ad\7\101\1\u00b8\4\101\22\uffff"+

+        "\2\101\3\uffff\3\101\1\uffff\1\u0087\1\uffff\1\u0087\2\uffff\2\101"+

+        "\1\uffff\3\101\1\uffff\1\101\2\uffff\1\u00ca\6\uffff\3\101\1\uffff"+

+        "\1\101\1\u00d0\11\101\1\uffff\10\101\1\u00e2\1\101\1\uffff\5\101"+

+        "\1\u00e9\1\u00ea\2\101\1\u0087\6\101\2\uffff\1\u00f3\1\101\1\u00f8"+

+        "\2\101\1\uffff\1\u00fb\4\101\1\u0100\12\101\1\u010b\1\uffff\5\101"+

+        "\1\u0111\2\uffff\10\101\1\uffff\4\101\1\uffff\1\u011e\1\101\1\uffff"+

+        "\4\101\1\uffff\4\101\1\u0128\5\101\1\uffff\5\101\1\uffff\1\u0133"+

+        "\1\u0134\1\101\1\u0136\10\101\1\uffff\1\u013f\7\101\1\u0147\1\uffff"+

+        "\1\u0148\1\u0149\1\u014a\1\u014b\1\u014c\3\101\1\u0150\1\101\2\uffff"+

+        "\1\101\1\uffff\1\u0153\2\101\1\u0156\4\101\1\uffff\3\101\1\u015e"+

+        "\2\101\1\u0161\6\uffff\1\u0162\1\u0163\1\101\1\uffff\2\101\1\uffff"+

+        "\1\u0167\1\u0168\1\uffff\6\101\1\u016f\1\uffff\2\101\3\uffff\1\101"+

+        "\1\u0173\1\101\2\uffff\3\101\1\u0178\2\101\1\uffff\3\101\1\uffff"+

+        "\1\u017e\3\101\1\uffff\1\u0182\1\u0183\1\101\1\u0185\1\101\1\uffff"+

+        "\3\101\2\uffff\1\u018a\1\uffff\4\101\1\uffff\1\u018f\2\101\1\u0192"+

+        "\1\uffff\1\u0193\1\101\2\uffff\11\101\1\u019e\1\uffff";

+    static final String DFA24_eofS =

+        "\u019f\uffff";

+    static final String DFA24_minS =

+        "\1\0\1\53\1\55\2\75\1\146\1\141\1\74\1\75\1\57\1\52\1\75\2\uffff"+

+        "\1\145\2\141\3\145\1\154\1\156\1\143\1\141\1\46\2\75\1\72\4\uffff"+

+        "\1\56\2\uffff\1\145\3\uffff\1\145\1\150\1\162\2\60\1\uffff\2\0\16"+

+        "\uffff\1\60\1\145\1\125\1\60\1\uffff\1\163\1\uffff\1\75\2\uffff"+

+        "\1\75\5\uffff\1\0\1\100\5\uffff\1\165\1\163\1\151\1\60\1\154\1\162"+

+        "\1\157\1\145\1\141\1\154\1\163\1\146\1\60\1\154\1\160\1\151\1\144"+

+        "\1\151\1\163\1\145\1\60\1\163\1\154\1\143\1\162\22\uffff\1\154\1"+

+        "\167\3\uffff\1\164\1\151\1\145\1\uffff\1\60\1\uffff\1\60\2\uffff"+

+        "\1\164\1\151\1\uffff\1\162\1\154\1\156\1\uffff\1\164\2\uffff\1\75"+

+        "\6\uffff\1\145\1\164\1\163\1\uffff\1\163\1\60\1\155\2\141\1\163"+

+        "\1\154\1\145\1\164\1\145\1\141\1\uffff\2\145\1\164\1\145\2\165\1"+

+        "\163\1\145\1\60\1\145\1\uffff\1\165\1\111\1\145\1\141\1\154\2\60"+

+        "\1\154\1\141\1\60\1\141\1\156\2\141\1\151\1\171\2\uffff\1\60\1\101"+

+        "\1\60\1\145\1\154\1\uffff\1\60\1\164\1\162\1\163\1\145\1\60\2\162"+

+        "\1\165\1\143\1\162\3\143\1\162\1\164\1\60\1\uffff\2\162\1\156\1"+

+        "\160\1\154\1\60\2\uffff\1\145\1\153\1\156\1\145\2\164\1\161\1\160"+

+        "\1\uffff\1\170\1\163\1\164\1\154\1\uffff\1\60\1\154\1\uffff\1\145"+

+        "\1\101\1\151\1\143\1\uffff\1\157\1\155\1\154\1\164\1\60\1\150\1"+

+        "\164\1\145\1\156\1\163\1\uffff\2\145\1\163\1\164\1\154\1\uffff\2"+

+        "\60\1\143\1\60\2\145\1\165\1\145\1\160\1\163\1\141\1\157\1\uffff"+

+        "\1\60\1\114\1\163\1\146\1\164\1\171\1\151\1\164\1\60\1\uffff\5\60"+

+        "\2\144\1\164\1\60\1\145\2\uffff\1\145\1\uffff\1\60\1\144\1\145\1"+

+        "\60\1\162\1\151\1\164\1\143\1\uffff\1\151\1\163\1\171\1\60\1\114"+

+        "\1\156\1\60\6\uffff\2\60\1\141\1\uffff\1\154\1\157\1\uffff\2\60"+

+        "\1\uffff\1\145\1\147\1\145\1\153\1\156\1\157\1\60\1\uffff\1\151"+

+        "\1\145\3\uffff\1\156\1\60\1\146\2\uffff\1\163\1\156\1\155\1\60\1"+

+        "\153\1\143\1\uffff\1\156\1\144\1\143\1\uffff\1\60\1\163\1\155\1"+

+        "\145\1\uffff\2\60\1\153\1\60\1\145\1\uffff\1\151\1\145\1\156\2\uffff"+

+        "\1\60\1\uffff\1\163\1\157\1\156\1\164\1\uffff\1\60\1\156\1\164\1"+

+        "\60\1\uffff\1\60\1\105\2\uffff\1\170\1\160\1\162\1\145\2\163\1\151"+

+        "\1\157\1\156\1\60\1\uffff";

+    static final String DFA24_maxS =

+        "\1\uffff\1\75\2\76\1\75\1\164\1\141\1\75\1\76\3\75\2\uffff\3\162"+

+        "\1\157\1\167\1\145\1\170\1\162\1\163\1\141\1\75\1\174\1\75\1\72"+

+        "\4\uffff\1\56\2\uffff\1\165\3\uffff\1\145\1\150\1\162\2\71\1\uffff"+

+        "\2\uffff\16\uffff\1\172\1\145\1\157\1\172\1\uffff\1\163\1\uffff"+

+        "\1\75\2\uffff\1\76\5\uffff\1\uffff\1\100\5\uffff\1\165\1\163\1\151"+

+        "\1\172\1\154\1\162\1\157\2\145\1\154\1\163\1\164\1\172\1\154\1\160"+

+        "\1\151\1\164\1\151\1\163\1\145\1\172\1\163\1\154\1\143\1\162\22"+

+        "\uffff\1\154\1\167\3\uffff\1\164\1\151\1\145\1\uffff\1\71\1\uffff"+

+        "\1\71\2\uffff\1\164\1\151\1\uffff\1\162\1\154\1\156\1\uffff\1\164"+

+        "\2\uffff\1\75\6\uffff\1\145\1\164\1\163\1\uffff\1\163\1\172\1\155"+

+        "\2\141\1\163\1\154\1\145\1\164\1\145\1\141\1\uffff\2\145\1\164\1"+

+        "\145\2\165\1\163\1\145\1\172\1\145\1\uffff\1\165\1\111\1\145\1\141"+

+        "\1\154\2\172\1\154\1\141\1\71\1\141\1\156\2\141\1\151\1\171\2\uffff"+

+        "\1\172\1\123\1\172\1\145\1\154\1\uffff\1\172\1\164\1\162\1\163\1"+

+        "\145\1\172\2\162\1\165\1\143\1\162\3\143\1\162\1\164\1\172\1\uffff"+

+        "\2\162\1\156\1\160\1\154\1\172\2\uffff\1\145\1\153\1\156\1\145\2"+

+        "\164\1\161\1\160\1\uffff\1\170\1\163\1\164\1\154\1\uffff\1\172\1"+

+        "\154\1\uffff\1\145\1\101\1\151\1\143\1\uffff\1\157\1\155\1\154\1"+

+        "\164\1\172\1\150\1\164\1\145\1\156\1\163\1\uffff\2\145\1\163\1\164"+

+        "\1\154\1\uffff\2\172\1\143\1\172\2\145\1\165\1\145\1\160\1\163\1"+

+        "\141\1\157\1\uffff\1\172\1\114\1\163\1\146\1\164\1\171\1\151\1\164"+

+        "\1\172\1\uffff\5\172\2\144\1\164\1\172\1\145\2\uffff\1\145\1\uffff"+

+        "\1\172\1\144\1\145\1\172\1\162\1\151\1\164\1\143\1\uffff\1\151\1"+

+        "\163\1\171\1\172\1\114\1\156\1\172\6\uffff\2\172\1\141\1\uffff\1"+

+        "\154\1\157\1\uffff\2\172\1\uffff\1\145\1\147\1\145\1\153\1\156\1"+

+        "\157\1\172\1\uffff\1\151\1\145\3\uffff\1\156\1\172\1\146\2\uffff"+

+        "\1\163\1\156\1\155\1\172\1\153\1\143\1\uffff\1\156\1\144\1\143\1"+

+        "\uffff\1\172\1\163\1\155\1\145\1\uffff\2\172\1\153\1\172\1\145\1"+

+        "\uffff\1\151\1\145\1\156\2\uffff\1\172\1\uffff\1\163\1\157\1\156"+

+        "\1\164\1\uffff\1\172\1\156\1\164\1\172\1\uffff\1\172\1\105\2\uffff"+

+        "\1\170\1\160\1\162\1\145\2\163\1\151\1\157\1\156\1\172\1\uffff";

+    static final String DFA24_acceptS =

+        "\14\uffff\1\24\1\25\16\uffff\1\67\1\71\1\72\1\73\1\uffff\1\103"+

+        "\1\104\1\uffff\1\114\1\115\1\124\5\uffff\1\150\2\uffff\1\155\1\156"+

+        "\1\1\1\47\1\16\1\2\1\50\1\105\1\17\1\3\1\70\1\46\1\4\1\23\4\uffff"+

+        "\1\150\1\uffff\1\11\1\uffff\1\7\1\12\1\uffff\1\10\1\51\1\122\1\20"+

+        "\1\53\2\uffff\1\21\1\52\1\22\1\24\1\25\31\uffff\1\54\1\76\1\101"+

+        "\1\55\1\75\1\77\1\56\1\100\1\66\1\74\1\67\1\71\1\72\1\73\1\116\1"+

+        "\102\1\103\1\104\2\uffff\1\114\1\115\1\124\3\uffff\1\147\1\uffff"+

+        "\1\154\1\uffff\1\151\1\155\2\uffff\1\137\3\uffff\1\126\1\uffff\1"+

+        "\57\1\13\1\uffff\1\60\1\14\1\120\1\152\1\123\1\153\3\uffff\1\145"+

+        "\13\uffff\1\135\12\uffff\1\130\20\uffff\1\61\1\15\5\uffff\1\136"+

+        "\21\uffff\1\41\6\uffff\1\113\1\125\10\uffff\1\26\4\uffff\1\111\2"+

+        "\uffff\1\144\4\uffff\1\132\12\uffff\1\127\5\uffff\1\110\14\uffff"+

+        "\1\27\11\uffff\1\112\12\uffff\1\134\1\140\1\uffff\1\121\10\uffff"+

+        "\1\37\7\uffff\1\33\1\131\1\34\1\106\1\141\1\40\3\uffff\1\142\2\uffff"+

+        "\1\36\2\uffff\1\6\7\uffff\1\35\2\uffff\1\133\1\146\1\44\3\uffff"+

+        "\1\42\1\107\6\uffff\1\143\3\uffff\1\45\4\uffff\1\65\5\uffff\1\5"+

+        "\3\uffff\1\30\1\32\1\uffff\1\43\4\uffff\1\31\4\uffff\1\117\2\uffff"+

+        "\1\64\1\62\12\uffff\1\63";

+    static final String DFA24_specialS =

+        "\1\3\54\uffff\1\1\1\0\36\uffff\1\2\u0151\uffff}>";

+    static final String[] DFA24_transitionS = {

+            "\11\60\2\57\2\60\1\57\22\60\1\57\1\4\1\56\1\60\1\14\1\13\1"+

+            "\30\1\55\1\35\1\36\1\11\1\1\1\34\1\2\1\40\1\12\1\52\11\53\1"+

+            "\33\1\46\1\7\1\3\1\10\1\37\1\60\32\54\1\41\1\60\1\42\1\32\1"+

+            "\54\1\60\1\26\1\51\1\20\1\21\1\24\1\17\1\54\1\6\1\5\2\54\1\47"+

+            "\1\54\1\43\1\25\1\27\1\54\1\23\1\22\1\16\2\54\1\50\3\54\1\44"+

+            "\1\31\1\45\1\15\uff81\60",

+            "\1\61\21\uffff\1\62",

+            "\1\64\17\uffff\1\65\1\66",

+            "\1\70\1\71",

+            "\1\73",

+            "\1\100\7\uffff\1\75\4\uffff\1\77\1\76",

+            "\1\102",

+            "\1\104\1\103",

+            "\1\106\1\107",

+            "\1\112\15\uffff\1\111",

+            "\1\115\4\uffff\1\116\15\uffff\1\114",

+            "\1\120",

+            "",

+            "",

+            "\1\125\2\uffff\1\126\6\uffff\1\127\2\uffff\1\124",

+            "\1\130\15\uffff\1\131\2\uffff\1\132",

+            "\1\136\12\uffff\1\134\2\uffff\1\135\2\uffff\1\133",

+            "\1\137\11\uffff\1\140",

+            "\1\141\17\uffff\1\142\1\uffff\1\143",

+            "\1\144",

+            "\1\146\13\uffff\1\145",

+            "\1\147\3\uffff\1\150",

+            "\1\153\10\uffff\1\152\6\uffff\1\151",

+            "\1\154",

+            "\1\156\26\uffff\1\155",

+            "\1\160\76\uffff\1\161",

+            "\1\163",

+            "\1\165",

+            "",

+            "",

+            "",

+            "",

+            "\1\173",

+            "",

+            "",

+            "\1\u0080\17\uffff\1\177",

+            "",

+            "",

+            "",

+            "\1\u0084",

+            "\1\u0085",

+            "\1\u0086",

+            "\10\u0088\2\u0089",

+            "\12\u008a",

+            "",

+            "\0\101",

+            "\0\u008b",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\13\101\1\u008e"+

+            "\6\101\1\u008d\7\101",

+            "\1\u0090",

+            "\1\u0092\31\uffff\1\u0091",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "",

+            "\1\u0094",

+            "",

+            "\1\u0095",

+            "",

+            "",

+            "\1\u0098\1\u0097",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "\100\u009b\1\u009a\uffbf\u009b",

+            "\1\u009c",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "\1\u009e",

+            "\1\u009f",

+            "\1\u00a0",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u00a2",

+            "\1\u00a3",

+            "\1\u00a4",

+            "\1\u00a5",

+            "\1\u00a7\3\uffff\1\u00a6",

+            "\1\u00a8",

+            "\1\u00a9",

+            "\1\u00ac\14\uffff\1\u00aa\1\u00ab",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u00ae",

+            "\1\u00af",

+            "\1\u00b0",

+            "\1\u00b2\5\uffff\1\u00b1\11\uffff\1\u00b3",

+            "\1\u00b4",

+            "\1\u00b5",

+            "\1\u00b6",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\3\101\1\u00b7"+

+            "\26\101",

+            "\1\u00b9",

+            "\1\u00ba",

+            "\1\u00bb",

+            "\1\u00bc",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "\1\u00bd",

+            "\1\u00be",

+            "",

+            "",

+            "",

+            "\1\u00bf",

+            "\1\u00c0",

+            "\1\u00c1",

+            "",

+            "\10\u00c2\2\u0089",

+            "",

+            "\12\u008a",

+            "",

+            "",

+            "\1\u00c3",

+            "\1\u00c4",

+            "",

+            "\1\u00c5",

+            "\1\u00c6",

+            "\1\u00c7",

+            "",

+            "\1\u00c8",

+            "",

+            "",

+            "\1\u00c9",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "\1\u00cb",

+            "\1\u00cc",

+            "\1\u00cd",

+            "",

+            "\1\u00ce",

+            "\12\101\7\uffff\1\u00cf\31\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u00d1",

+            "\1\u00d2",

+            "\1\u00d3",

+            "\1\u00d4",

+            "\1\u00d5",

+            "\1\u00d6",

+            "\1\u00d7",

+            "\1\u00d8",

+            "\1\u00d9",

+            "",

+            "\1\u00da",

+            "\1\u00db",

+            "\1\u00dc",

+            "\1\u00dd",

+            "\1\u00de",

+            "\1\u00df",

+            "\1\u00e0",

+            "\1\u00e1",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u00e3",

+            "",

+            "\1\u00e4",

+            "\1\u00e5",

+            "\1\u00e6",

+            "\1\u00e7",

+            "\1\u00e8",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u00eb",

+            "\1\u00ec",

+            "\10\u00c2\2\u0089",

+            "\1\u00ed",

+            "\1\u00ee",

+            "\1\u00ef",

+            "\1\u00f0",

+            "\1\u00f1",

+            "\1\u00f2",

+            "",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u00f5\1\u00f7\2\uffff\1\u00f4\15\uffff\1\u00f6",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u00f9",

+            "\1\u00fa",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u00fc",

+            "\1\u00fd",

+            "\1\u00fe",

+            "\1\u00ff",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0101",

+            "\1\u0102",

+            "\1\u0103",

+            "\1\u0104",

+            "\1\u0105",

+            "\1\u0106",

+            "\1\u0107",

+            "\1\u0108",

+            "\1\u0109",

+            "\1\u010a",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "",

+            "\1\u010c",

+            "\1\u010d",

+            "\1\u010e",

+            "\1\u010f",

+            "\1\u0110",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "",

+            "",

+            "\1\u0112",

+            "\1\u0113",

+            "\1\u0114",

+            "\1\u0115",

+            "\1\u0116",

+            "\1\u0117",

+            "\1\u0118",

+            "\1\u0119",

+            "",

+            "\1\u011a",

+            "\1\u011b",

+            "\1\u011c",

+            "\1\u011d",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u011f",

+            "",

+            "\1\u0120",

+            "\1\u0121",

+            "\1\u0122",

+            "\1\u0123",

+            "",

+            "\1\u0124",

+            "\1\u0125",

+            "\1\u0126",

+            "\1\u0127",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0129",

+            "\1\u012a",

+            "\1\u012b",

+            "\1\u012c",

+            "\1\u012d",

+            "",

+            "\1\u012e",

+            "\1\u012f",

+            "\1\u0130",

+            "\1\u0131",

+            "\1\u0132",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0135",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0137",

+            "\1\u0138",

+            "\1\u0139",

+            "\1\u013a",

+            "\1\u013b",

+            "\1\u013c",

+            "\1\u013d",

+            "\1\u013e",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0140",

+            "\1\u0141",

+            "\1\u0142",

+            "\1\u0143",

+            "\1\u0144",

+            "\1\u0145",

+            "\1\u0146",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u014d",

+            "\1\u014e",

+            "\1\u014f",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0151",

+            "",

+            "",

+            "\1\u0152",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0154",

+            "\1\u0155",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0157",

+            "\1\u0158",

+            "\1\u0159",

+            "\1\u015a",

+            "",

+            "\1\u015b",

+            "\1\u015c",

+            "\1\u015d",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u015f",

+            "\1\u0160",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0164",

+            "",

+            "\1\u0165",

+            "\1\u0166",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "",

+            "\1\u0169",

+            "\1\u016a",

+            "\1\u016b",

+            "\1\u016c",

+            "\1\u016d",

+            "\1\u016e",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "",

+            "\1\u0170",

+            "\1\u0171",

+            "",

+            "",

+            "",

+            "\1\u0172",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0174",

+            "",

+            "",

+            "\1\u0175",

+            "\1\u0176",

+            "\1\u0177",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0179",

+            "\1\u017a",

+            "",

+            "\1\u017b",

+            "\1\u017c",

+            "\1\u017d",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u017f",

+            "\1\u0180",

+            "\1\u0181",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0184",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0186",

+            "",

+            "\1\u0187",

+            "\1\u0188",

+            "\1\u0189",

+            "",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "",

+            "\1\u018b",

+            "\1\u018c",

+            "\1\u018d",

+            "\1\u018e",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0190",

+            "\1\u0191",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            "\1\u0194",

+            "",

+            "",

+            "\1\u0195",

+            "\1\u0196",

+            "\1\u0197",

+            "\1\u0198",

+            "\1\u0199",

+            "\1\u019a",

+            "\1\u019b",

+            "\1\u019c",

+            "\1\u019d",

+            "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101",

+            ""

+    };

+

+    static final short[] DFA24_eot = DFA.unpackEncodedString(DFA24_eotS);

+    static final short[] DFA24_eof = DFA.unpackEncodedString(DFA24_eofS);

+    static final char[] DFA24_min = DFA.unpackEncodedStringToUnsignedChars(DFA24_minS);

+    static final char[] DFA24_max = DFA.unpackEncodedStringToUnsignedChars(DFA24_maxS);

+    static final short[] DFA24_accept = DFA.unpackEncodedString(DFA24_acceptS);

+    static final short[] DFA24_special = DFA.unpackEncodedString(DFA24_specialS);

+    static final short[][] DFA24_transition;

+

+    static {

+        int numStates = DFA24_transitionS.length;

+        DFA24_transition = new short[numStates][];

+        for (int i=0; i<numStates; i++) {

+            DFA24_transition[i] = DFA.unpackEncodedString(DFA24_transitionS[i]);

+        }

+    }

+

+    class DFA24 extends DFA {

+

+        public DFA24(BaseRecognizer recognizer) {

+            this.recognizer = recognizer;

+            this.decisionNumber = 24;

+            this.eot = DFA24_eot;

+            this.eof = DFA24_eof;

+            this.min = DFA24_min;

+            this.max = DFA24_max;

+            this.accept = DFA24_accept;

+            this.special = DFA24_special;

+            this.transition = DFA24_transition;

+        }

+        public String getDescription() {

+            return "1:1: Tokens : ( T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | T__113 | RULE_INTEGERVALUE | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_INT | RULE_WS | RULE_ANY_OTHER );";

+        }

+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {

+            IntStream input = _input;

+        	int _s = s;

+            switch ( s ) {

+                    case 0 : 

+                        int LA24_46 = input.LA(1);

+

+                        s = -1;

+                        if ( ((LA24_46>='\u0000' && LA24_46<='\uFFFF')) ) {s = 139;}

+

+                        else s = 48;

+

+                        if ( s>=0 ) return s;

+                        break;

+                    case 1 : 

+                        int LA24_45 = input.LA(1);

+

+                        s = -1;

+                        if ( ((LA24_45>='\u0000' && LA24_45<='\uFFFF')) ) {s = 65;}

+

+                        else s = 48;

+

+                        if ( s>=0 ) return s;

+                        break;

+                    case 2 : 

+                        int LA24_77 = input.LA(1);

+

+                        s = -1;

+                        if ( (LA24_77=='@') ) {s = 154;}

+

+                        else if ( ((LA24_77>='\u0000' && LA24_77<='?')||(LA24_77>='A' && LA24_77<='\uFFFF')) ) {s = 155;}

+

+                        if ( s>=0 ) return s;

+                        break;

+                    case 3 : 

+                        int LA24_0 = input.LA(1);

+

+                        s = -1;

+                        if ( (LA24_0=='+') ) {s = 1;}

+

+                        else if ( (LA24_0=='-') ) {s = 2;}

+

+                        else if ( (LA24_0=='=') ) {s = 3;}

+

+                        else if ( (LA24_0=='!') ) {s = 4;}

+

+                        else if ( (LA24_0=='i') ) {s = 5;}

+

+                        else if ( (LA24_0=='h') ) {s = 6;}

+

+                        else if ( (LA24_0=='<') ) {s = 7;}

+

+                        else if ( (LA24_0=='>') ) {s = 8;}

+

+                        else if ( (LA24_0=='*') ) {s = 9;}

+

+                        else if ( (LA24_0=='/') ) {s = 10;}

+

+                        else if ( (LA24_0=='%') ) {s = 11;}

+

+                        else if ( (LA24_0=='$') ) {s = 12;}

+

+                        else if ( (LA24_0=='~') ) {s = 13;}

+

+                        else if ( (LA24_0=='t') ) {s = 14;}

+

+                        else if ( (LA24_0=='f') ) {s = 15;}

+

+                        else if ( (LA24_0=='c') ) {s = 16;}

+

+                        else if ( (LA24_0=='d') ) {s = 17;}

+

+                        else if ( (LA24_0=='s') ) {s = 18;}

+

+                        else if ( (LA24_0=='r') ) {s = 19;}

+

+                        else if ( (LA24_0=='e') ) {s = 20;}

+

+                        else if ( (LA24_0=='o') ) {s = 21;}

+

+                        else if ( (LA24_0=='a') ) {s = 22;}

+

+                        else if ( (LA24_0=='p') ) {s = 23;}

+

+                        else if ( (LA24_0=='&') ) {s = 24;}

+

+                        else if ( (LA24_0=='|') ) {s = 25;}

+

+                        else if ( (LA24_0=='^') ) {s = 26;}

+

+                        else if ( (LA24_0==':') ) {s = 27;}

+

+                        else if ( (LA24_0==',') ) {s = 28;}

+

+                        else if ( (LA24_0=='(') ) {s = 29;}

+

+                        else if ( (LA24_0==')') ) {s = 30;}

+

+                        else if ( (LA24_0=='?') ) {s = 31;}

+

+                        else if ( (LA24_0=='.') ) {s = 32;}

+

+                        else if ( (LA24_0=='[') ) {s = 33;}

+

+                        else if ( (LA24_0==']') ) {s = 34;}

+

+                        else if ( (LA24_0=='n') ) {s = 35;}

+

+                        else if ( (LA24_0=='{') ) {s = 36;}

+

+                        else if ( (LA24_0=='}') ) {s = 37;}

+

+                        else if ( (LA24_0==';') ) {s = 38;}

+

+                        else if ( (LA24_0=='l') ) {s = 39;}

+

+                        else if ( (LA24_0=='w') ) {s = 40;}

+

+                        else if ( (LA24_0=='b') ) {s = 41;}

+

+                        else if ( (LA24_0=='0') ) {s = 42;}

+

+                        else if ( ((LA24_0>='1' && LA24_0<='9')) ) {s = 43;}

+

+                        else if ( ((LA24_0>='A' && LA24_0<='Z')||LA24_0=='_'||LA24_0=='g'||(LA24_0>='j' && LA24_0<='k')||LA24_0=='m'||LA24_0=='q'||(LA24_0>='u' && LA24_0<='v')||(LA24_0>='x' && LA24_0<='z')) ) {s = 44;}

+

+                        else if ( (LA24_0=='\'') ) {s = 45;}

+

+                        else if ( (LA24_0=='\"') ) {s = 46;}

+

+                        else if ( ((LA24_0>='\t' && LA24_0<='\n')||LA24_0=='\r'||LA24_0==' ') ) {s = 47;}

+

+                        else if ( ((LA24_0>='\u0000' && LA24_0<='\b')||(LA24_0>='\u000B' && LA24_0<='\f')||(LA24_0>='\u000E' && LA24_0<='\u001F')||LA24_0=='#'||LA24_0=='@'||LA24_0=='\\'||LA24_0=='`'||(LA24_0>='\u007F' && LA24_0<='\uFFFF')) ) {s = 48;}

+

+                        if ( s>=0 ) return s;

+                        break;

+            }

+            NoViableAltException nvae =

+                new NoViableAltException(getDescription(), 24, _s, input);

+            error(nvae);

+            throw nvae;

+        }

+    }

+ 

+

+}
\ No newline at end of file
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlfParser.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlfParser.java
new file mode 100644
index 00000000000..19643ab64f5
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlfParser.java
@@ -0,0 +1,53155 @@
+package org.eclipse.papyrus.alf.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.papyrus.alf.services.AlfGrammarAccess;

+

+

+

+import org.antlr.runtime.*;

+import java.util.Stack;

+import java.util.List;

+import java.util.ArrayList;

+

+@SuppressWarnings("all")
+public class InternalAlfParser extends AbstractInternalContentAssistParser {

+    public static final String[] tokenNames = new String[] {

+        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_INTEGERVALUE", "RULE_STRING", "RULE_ID", "RULE_INT", "RULE_WS", "RULE_ANY_OTHER", "'++'", "'--'", "'=='", "'!='", "'instanceof'", "'hastype'", "'<'", "'>'", "'<='", "'>='", "'<<'", "'>>'", "'>>>'", "'+'", "'-'", "'*'", "'/'", "'%'", "'!'", "'$'", "'~'", "'true'", "'false'", "'createLink'", "'destroyLink'", "'clearAssoc'", "'select'", "'reject'", "'collect'", "'iterate'", "'forAll'", "'exists'", "'one'", "'isolated'", "'determined'", "'assured'", "'parallel'", "'='", "'+='", "'-='", "'*='", "'%='", "'/='", "'&='", "'|='", "'^='", "'<<='", "'>>='", "'>>>='", "'testExpression'", "'testAssignmentExpression'", "'testStatement'", "'testBlock'", "'::'", "','", "'=>'", "'('", "')'", "'?'", "':'", "'||'", "'&&'", "'|'", "'^'", "'&'", "'.'", "'['", "']'", "'->'", "'reduce'", "'isUnique'", "'null'", "'this'", "'super'", "'new'", "'{'", "'}'", "'..'", "'allInstances'", "'/*@'", "'inline'", "'*/'", "'//@'", "';'", "'let'", "'if'", "'else'", "'or'", "'switch'", "'case'", "'default'", "'while'", "'do'", "'for'", "'in'", "'break'", "'return'", "'accept'", "'classify'", "'from'", "'to'", "'ordered'"

+    };

+    public static final int RULE_ID=8;

+    public static final int T__29=29;

+    public static final int T__28=28;

+    public static final int T__27=27;

+    public static final int T__26=26;

+    public static final int T__25=25;

+    public static final int T__24=24;

+    public static final int T__23=23;

+    public static final int T__22=22;

+    public static final int RULE_ANY_OTHER=11;

+    public static final int T__21=21;

+    public static final int T__20=20;

+    public static final int EOF=-1;

+    public static final int T__93=93;

+    public static final int T__19=19;

+    public static final int T__94=94;

+    public static final int T__91=91;

+    public static final int T__92=92;

+    public static final int T__16=16;

+    public static final int T__15=15;

+    public static final int T__90=90;

+    public static final int T__18=18;

+    public static final int T__17=17;

+    public static final int T__12=12;

+    public static final int T__14=14;

+    public static final int T__13=13;

+    public static final int T__99=99;

+    public static final int RULE_INTEGERVALUE=6;

+    public static final int T__98=98;

+    public static final int T__97=97;

+    public static final int T__96=96;

+    public static final int T__95=95;

+    public static final int T__80=80;

+    public static final int T__81=81;

+    public static final int T__82=82;

+    public static final int T__83=83;

+    public static final int T__85=85;

+    public static final int T__84=84;

+    public static final int T__87=87;

+    public static final int T__86=86;

+    public static final int T__89=89;

+    public static final int T__88=88;

+    public static final int RULE_ML_COMMENT=4;

+    public static final int RULE_STRING=7;

+    public static final int T__71=71;

+    public static final int T__72=72;

+    public static final int T__70=70;

+    public static final int T__76=76;

+    public static final int T__75=75;

+    public static final int T__74=74;

+    public static final int T__73=73;

+    public static final int T__79=79;

+    public static final int T__78=78;

+    public static final int T__77=77;

+    public static final int T__68=68;

+    public static final int T__69=69;

+    public static final int T__66=66;

+    public static final int T__67=67;

+    public static final int T__64=64;

+    public static final int T__65=65;

+    public static final int T__62=62;

+    public static final int T__63=63;

+    public static final int T__61=61;

+    public static final int T__60=60;

+    public static final int T__55=55;

+    public static final int T__56=56;

+    public static final int T__57=57;

+    public static final int T__58=58;

+    public static final int T__51=51;

+    public static final int T__52=52;

+    public static final int T__53=53;

+    public static final int T__54=54;

+    public static final int T__107=107;

+    public static final int T__108=108;

+    public static final int T__109=109;

+    public static final int T__103=103;

+    public static final int T__59=59;

+    public static final int T__104=104;

+    public static final int T__105=105;

+    public static final int T__106=106;

+    public static final int T__111=111;

+    public static final int T__110=110;

+    public static final int RULE_INT=9;

+    public static final int T__113=113;

+    public static final int T__112=112;

+    public static final int T__50=50;

+    public static final int T__42=42;

+    public static final int T__43=43;

+    public static final int T__40=40;

+    public static final int T__41=41;

+    public static final int T__46=46;

+    public static final int T__47=47;

+    public static final int T__44=44;

+    public static final int T__45=45;

+    public static final int T__48=48;

+    public static final int T__49=49;

+    public static final int T__102=102;

+    public static final int T__101=101;

+    public static final int T__100=100;

+    public static final int RULE_SL_COMMENT=5;

+    public static final int T__30=30;

+    public static final int T__31=31;

+    public static final int T__32=32;

+    public static final int T__33=33;

+    public static final int T__34=34;

+    public static final int T__35=35;

+    public static final int T__36=36;

+    public static final int T__37=37;

+    public static final int T__38=38;

+    public static final int T__39=39;

+    public static final int RULE_WS=10;

+

+    // delegates

+    // delegators

+

+

+        public InternalAlfParser(TokenStream input) {

+            this(input, new RecognizerSharedState());

+        }

+        public InternalAlfParser(TokenStream input, RecognizerSharedState state) {

+            super(input, state);

+             

+        }

+        

+

+    public String[] getTokenNames() { return InternalAlfParser.tokenNames; }

+    public String getGrammarFileName() { return "../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g"; }

+

+

+     

+     	private AlfGrammarAccess grammarAccess;

+     	

+        public void setGrammarAccess(AlfGrammarAccess grammarAccess) {

+        	this.grammarAccess = grammarAccess;

+        }

+        

+        @Override

+        protected Grammar getGrammar() {

+        	return grammarAccess.getGrammar();

+        }

+        

+        @Override

+        protected String getValueForTokenName(String tokenName) {

+        	return tokenName;

+        }

+

+

+

+

+    // $ANTLR start "entryRuleTest"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:60:1: entryRuleTest : ruleTest EOF ;

+    public final void entryRuleTest() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:61:1: ( ruleTest EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:62:1: ruleTest EOF

+            {

+             before(grammarAccess.getTestRule()); 

+            pushFollow(FOLLOW_ruleTest_in_entryRuleTest61);

+            ruleTest();

+

+            state._fsp--;

+

+             after(grammarAccess.getTestRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleTest68); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleTest"

+

+

+    // $ANTLR start "ruleTest"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:69:1: ruleTest : ( ( rule__Test__Group__0 ) ) ;

+    public final void ruleTest() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:73:2: ( ( ( rule__Test__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:74:1: ( ( rule__Test__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:74:1: ( ( rule__Test__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:75:1: ( rule__Test__Group__0 )

+            {

+             before(grammarAccess.getTestAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:76:1: ( rule__Test__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:76:2: rule__Test__Group__0

+            {

+            pushFollow(FOLLOW_rule__Test__Group__0_in_ruleTest94);

+            rule__Test__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getTestAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleTest"

+

+

+    // $ANTLR start "entryRuleLITERAL"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:88:1: entryRuleLITERAL : ruleLITERAL EOF ;

+    public final void entryRuleLITERAL() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:89:1: ( ruleLITERAL EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:90:1: ruleLITERAL EOF

+            {

+             before(grammarAccess.getLITERALRule()); 

+            pushFollow(FOLLOW_ruleLITERAL_in_entryRuleLITERAL121);

+            ruleLITERAL();

+

+            state._fsp--;

+

+             after(grammarAccess.getLITERALRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleLITERAL128); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleLITERAL"

+

+

+    // $ANTLR start "ruleLITERAL"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:97:1: ruleLITERAL : ( ( rule__LITERAL__Alternatives ) ) ;

+    public final void ruleLITERAL() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:101:2: ( ( ( rule__LITERAL__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:102:1: ( ( rule__LITERAL__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:102:1: ( ( rule__LITERAL__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:103:1: ( rule__LITERAL__Alternatives )

+            {

+             before(grammarAccess.getLITERALAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:104:1: ( rule__LITERAL__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:104:2: rule__LITERAL__Alternatives

+            {

+            pushFollow(FOLLOW_rule__LITERAL__Alternatives_in_ruleLITERAL154);

+            rule__LITERAL__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLITERALAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleLITERAL"

+

+

+    // $ANTLR start "entryRuleBOOLEAN_LITERAL"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:116:1: entryRuleBOOLEAN_LITERAL : ruleBOOLEAN_LITERAL EOF ;

+    public final void entryRuleBOOLEAN_LITERAL() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:117:1: ( ruleBOOLEAN_LITERAL EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:118:1: ruleBOOLEAN_LITERAL EOF

+            {

+             before(grammarAccess.getBOOLEAN_LITERALRule()); 

+            pushFollow(FOLLOW_ruleBOOLEAN_LITERAL_in_entryRuleBOOLEAN_LITERAL181);

+            ruleBOOLEAN_LITERAL();

+

+            state._fsp--;

+

+             after(grammarAccess.getBOOLEAN_LITERALRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleBOOLEAN_LITERAL188); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleBOOLEAN_LITERAL"

+

+

+    // $ANTLR start "ruleBOOLEAN_LITERAL"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:125:1: ruleBOOLEAN_LITERAL : ( ( rule__BOOLEAN_LITERAL__ValueAssignment ) ) ;

+    public final void ruleBOOLEAN_LITERAL() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:129:2: ( ( ( rule__BOOLEAN_LITERAL__ValueAssignment ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:130:1: ( ( rule__BOOLEAN_LITERAL__ValueAssignment ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:130:1: ( ( rule__BOOLEAN_LITERAL__ValueAssignment ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:131:1: ( rule__BOOLEAN_LITERAL__ValueAssignment )

+            {

+             before(grammarAccess.getBOOLEAN_LITERALAccess().getValueAssignment()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:132:1: ( rule__BOOLEAN_LITERAL__ValueAssignment )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:132:2: rule__BOOLEAN_LITERAL__ValueAssignment

+            {

+            pushFollow(FOLLOW_rule__BOOLEAN_LITERAL__ValueAssignment_in_ruleBOOLEAN_LITERAL214);

+            rule__BOOLEAN_LITERAL__ValueAssignment();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getBOOLEAN_LITERALAccess().getValueAssignment()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleBOOLEAN_LITERAL"

+

+

+    // $ANTLR start "entryRuleNUMBER_LITERAL"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:144:1: entryRuleNUMBER_LITERAL : ruleNUMBER_LITERAL EOF ;

+    public final void entryRuleNUMBER_LITERAL() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:145:1: ( ruleNUMBER_LITERAL EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:146:1: ruleNUMBER_LITERAL EOF

+            {

+             before(grammarAccess.getNUMBER_LITERALRule()); 

+            pushFollow(FOLLOW_ruleNUMBER_LITERAL_in_entryRuleNUMBER_LITERAL241);

+            ruleNUMBER_LITERAL();

+

+            state._fsp--;

+

+             after(grammarAccess.getNUMBER_LITERALRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleNUMBER_LITERAL248); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleNUMBER_LITERAL"

+

+

+    // $ANTLR start "ruleNUMBER_LITERAL"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:153:1: ruleNUMBER_LITERAL : ( ( rule__NUMBER_LITERAL__Alternatives ) ) ;

+    public final void ruleNUMBER_LITERAL() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:157:2: ( ( ( rule__NUMBER_LITERAL__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:158:1: ( ( rule__NUMBER_LITERAL__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:158:1: ( ( rule__NUMBER_LITERAL__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:159:1: ( rule__NUMBER_LITERAL__Alternatives )

+            {

+             before(grammarAccess.getNUMBER_LITERALAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:160:1: ( rule__NUMBER_LITERAL__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:160:2: rule__NUMBER_LITERAL__Alternatives

+            {

+            pushFollow(FOLLOW_rule__NUMBER_LITERAL__Alternatives_in_ruleNUMBER_LITERAL274);

+            rule__NUMBER_LITERAL__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNUMBER_LITERALAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleNUMBER_LITERAL"

+

+

+    // $ANTLR start "entryRuleINTEGER_LITERAL"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:172:1: entryRuleINTEGER_LITERAL : ruleINTEGER_LITERAL EOF ;

+    public final void entryRuleINTEGER_LITERAL() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:173:1: ( ruleINTEGER_LITERAL EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:174:1: ruleINTEGER_LITERAL EOF

+            {

+             before(grammarAccess.getINTEGER_LITERALRule()); 

+            pushFollow(FOLLOW_ruleINTEGER_LITERAL_in_entryRuleINTEGER_LITERAL301);

+            ruleINTEGER_LITERAL();

+

+            state._fsp--;

+

+             after(grammarAccess.getINTEGER_LITERALRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleINTEGER_LITERAL308); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleINTEGER_LITERAL"

+

+

+    // $ANTLR start "ruleINTEGER_LITERAL"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:181:1: ruleINTEGER_LITERAL : ( ( rule__INTEGER_LITERAL__ValueAssignment ) ) ;

+    public final void ruleINTEGER_LITERAL() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:185:2: ( ( ( rule__INTEGER_LITERAL__ValueAssignment ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:186:1: ( ( rule__INTEGER_LITERAL__ValueAssignment ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:186:1: ( ( rule__INTEGER_LITERAL__ValueAssignment ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:187:1: ( rule__INTEGER_LITERAL__ValueAssignment )

+            {

+             before(grammarAccess.getINTEGER_LITERALAccess().getValueAssignment()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:188:1: ( rule__INTEGER_LITERAL__ValueAssignment )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:188:2: rule__INTEGER_LITERAL__ValueAssignment

+            {

+            pushFollow(FOLLOW_rule__INTEGER_LITERAL__ValueAssignment_in_ruleINTEGER_LITERAL334);

+            rule__INTEGER_LITERAL__ValueAssignment();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getINTEGER_LITERALAccess().getValueAssignment()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleINTEGER_LITERAL"

+

+

+    // $ANTLR start "entryRuleUNLIMITED_LITERAL"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:200:1: entryRuleUNLIMITED_LITERAL : ruleUNLIMITED_LITERAL EOF ;

+    public final void entryRuleUNLIMITED_LITERAL() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:201:1: ( ruleUNLIMITED_LITERAL EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:202:1: ruleUNLIMITED_LITERAL EOF

+            {

+             before(grammarAccess.getUNLIMITED_LITERALRule()); 

+            pushFollow(FOLLOW_ruleUNLIMITED_LITERAL_in_entryRuleUNLIMITED_LITERAL361);

+            ruleUNLIMITED_LITERAL();

+

+            state._fsp--;

+

+             after(grammarAccess.getUNLIMITED_LITERALRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleUNLIMITED_LITERAL368); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleUNLIMITED_LITERAL"

+

+

+    // $ANTLR start "ruleUNLIMITED_LITERAL"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:209:1: ruleUNLIMITED_LITERAL : ( ( rule__UNLIMITED_LITERAL__ValueAssignment ) ) ;

+    public final void ruleUNLIMITED_LITERAL() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:213:2: ( ( ( rule__UNLIMITED_LITERAL__ValueAssignment ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:214:1: ( ( rule__UNLIMITED_LITERAL__ValueAssignment ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:214:1: ( ( rule__UNLIMITED_LITERAL__ValueAssignment ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:215:1: ( rule__UNLIMITED_LITERAL__ValueAssignment )

+            {

+             before(grammarAccess.getUNLIMITED_LITERALAccess().getValueAssignment()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:216:1: ( rule__UNLIMITED_LITERAL__ValueAssignment )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:216:2: rule__UNLIMITED_LITERAL__ValueAssignment

+            {

+            pushFollow(FOLLOW_rule__UNLIMITED_LITERAL__ValueAssignment_in_ruleUNLIMITED_LITERAL394);

+            rule__UNLIMITED_LITERAL__ValueAssignment();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getUNLIMITED_LITERALAccess().getValueAssignment()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleUNLIMITED_LITERAL"

+

+

+    // $ANTLR start "entryRuleSTRING_LITERAL"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:228:1: entryRuleSTRING_LITERAL : ruleSTRING_LITERAL EOF ;

+    public final void entryRuleSTRING_LITERAL() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:229:1: ( ruleSTRING_LITERAL EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:230:1: ruleSTRING_LITERAL EOF

+            {

+             before(grammarAccess.getSTRING_LITERALRule()); 

+            pushFollow(FOLLOW_ruleSTRING_LITERAL_in_entryRuleSTRING_LITERAL421);

+            ruleSTRING_LITERAL();

+

+            state._fsp--;

+

+             after(grammarAccess.getSTRING_LITERALRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSTRING_LITERAL428); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSTRING_LITERAL"

+

+

+    // $ANTLR start "ruleSTRING_LITERAL"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:237:1: ruleSTRING_LITERAL : ( ( rule__STRING_LITERAL__ValueAssignment ) ) ;

+    public final void ruleSTRING_LITERAL() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:241:2: ( ( ( rule__STRING_LITERAL__ValueAssignment ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:242:1: ( ( rule__STRING_LITERAL__ValueAssignment ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:242:1: ( ( rule__STRING_LITERAL__ValueAssignment ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:243:1: ( rule__STRING_LITERAL__ValueAssignment )

+            {

+             before(grammarAccess.getSTRING_LITERALAccess().getValueAssignment()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:244:1: ( rule__STRING_LITERAL__ValueAssignment )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:244:2: rule__STRING_LITERAL__ValueAssignment

+            {

+            pushFollow(FOLLOW_rule__STRING_LITERAL__ValueAssignment_in_ruleSTRING_LITERAL454);

+            rule__STRING_LITERAL__ValueAssignment();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSTRING_LITERALAccess().getValueAssignment()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSTRING_LITERAL"

+

+

+    // $ANTLR start "entryRuleNameExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:256:1: entryRuleNameExpression : ruleNameExpression EOF ;

+    public final void entryRuleNameExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:257:1: ( ruleNameExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:258:1: ruleNameExpression EOF

+            {

+             before(grammarAccess.getNameExpressionRule()); 

+            pushFollow(FOLLOW_ruleNameExpression_in_entryRuleNameExpression481);

+            ruleNameExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getNameExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleNameExpression488); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleNameExpression"

+

+

+    // $ANTLR start "ruleNameExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:265:1: ruleNameExpression : ( ( rule__NameExpression__Group__0 ) ) ;

+    public final void ruleNameExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:269:2: ( ( ( rule__NameExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:270:1: ( ( rule__NameExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:270:1: ( ( rule__NameExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:271:1: ( rule__NameExpression__Group__0 )

+            {

+             before(grammarAccess.getNameExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:272:1: ( rule__NameExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:272:2: rule__NameExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__NameExpression__Group__0_in_ruleNameExpression514);

+            rule__NameExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNameExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleNameExpression"

+

+

+    // $ANTLR start "entryRuleQualifiedNamePath"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:284:1: entryRuleQualifiedNamePath : ruleQualifiedNamePath EOF ;

+    public final void entryRuleQualifiedNamePath() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:285:1: ( ruleQualifiedNamePath EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:286:1: ruleQualifiedNamePath EOF

+            {

+             before(grammarAccess.getQualifiedNamePathRule()); 

+            pushFollow(FOLLOW_ruleQualifiedNamePath_in_entryRuleQualifiedNamePath541);

+            ruleQualifiedNamePath();

+

+            state._fsp--;

+

+             after(grammarAccess.getQualifiedNamePathRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleQualifiedNamePath548); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleQualifiedNamePath"

+

+

+    // $ANTLR start "ruleQualifiedNamePath"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:293:1: ruleQualifiedNamePath : ( ( ( rule__QualifiedNamePath__Group__0 ) ) ( ( rule__QualifiedNamePath__Group__0 )* ) ) ;

+    public final void ruleQualifiedNamePath() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:297:2: ( ( ( ( rule__QualifiedNamePath__Group__0 ) ) ( ( rule__QualifiedNamePath__Group__0 )* ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:298:1: ( ( ( rule__QualifiedNamePath__Group__0 ) ) ( ( rule__QualifiedNamePath__Group__0 )* ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:298:1: ( ( ( rule__QualifiedNamePath__Group__0 ) ) ( ( rule__QualifiedNamePath__Group__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:299:1: ( ( rule__QualifiedNamePath__Group__0 ) ) ( ( rule__QualifiedNamePath__Group__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:299:1: ( ( rule__QualifiedNamePath__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:300:1: ( rule__QualifiedNamePath__Group__0 )

+            {

+             before(grammarAccess.getQualifiedNamePathAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:301:1: ( rule__QualifiedNamePath__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:301:2: rule__QualifiedNamePath__Group__0

+            {

+            pushFollow(FOLLOW_rule__QualifiedNamePath__Group__0_in_ruleQualifiedNamePath576);

+            rule__QualifiedNamePath__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getQualifiedNamePathAccess().getGroup()); 

+

+            }

+

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:304:1: ( ( rule__QualifiedNamePath__Group__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:305:1: ( rule__QualifiedNamePath__Group__0 )*

+            {

+             before(grammarAccess.getQualifiedNamePathAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:306:1: ( rule__QualifiedNamePath__Group__0 )*

+            loop1:

+            do {

+                int alt1=2;

+                int LA1_0 = input.LA(1);

+

+                if ( (LA1_0==RULE_ID) ) {

+                    int LA1_2 = input.LA(2);

+

+                    if ( (LA1_2==18) ) {

+                        int LA1_3 = input.LA(3);

+

+                        if ( (LA1_3==RULE_ID) ) {

+                            int LA1_5 = input.LA(4);

+

+                            if ( (LA1_5==67) ) {

+                                alt1=1;

+                            }

+

+

+                        }

+

+

+                    }

+                    else if ( (LA1_2==65) ) {

+                        alt1=1;

+                    }

+

+

+                }

+

+

+                switch (alt1) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:306:2: rule__QualifiedNamePath__Group__0

+            	    {

+            	    pushFollow(FOLLOW_rule__QualifiedNamePath__Group__0_in_ruleQualifiedNamePath588);

+            	    rule__QualifiedNamePath__Group__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop1;

+                }

+            } while (true);

+

+             after(grammarAccess.getQualifiedNamePathAccess().getGroup()); 

+

+            }

+

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleQualifiedNamePath"

+

+

+    // $ANTLR start "entryRuleUnqualifiedName"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:319:1: entryRuleUnqualifiedName : ruleUnqualifiedName EOF ;

+    public final void entryRuleUnqualifiedName() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:320:1: ( ruleUnqualifiedName EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:321:1: ruleUnqualifiedName EOF

+            {

+             before(grammarAccess.getUnqualifiedNameRule()); 

+            pushFollow(FOLLOW_ruleUnqualifiedName_in_entryRuleUnqualifiedName618);

+            ruleUnqualifiedName();

+

+            state._fsp--;

+

+             after(grammarAccess.getUnqualifiedNameRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleUnqualifiedName625); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleUnqualifiedName"

+

+

+    // $ANTLR start "ruleUnqualifiedName"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:328:1: ruleUnqualifiedName : ( ( rule__UnqualifiedName__Group__0 ) ) ;

+    public final void ruleUnqualifiedName() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:332:2: ( ( ( rule__UnqualifiedName__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:333:1: ( ( rule__UnqualifiedName__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:333:1: ( ( rule__UnqualifiedName__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:334:1: ( rule__UnqualifiedName__Group__0 )

+            {

+             before(grammarAccess.getUnqualifiedNameAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:335:1: ( rule__UnqualifiedName__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:335:2: rule__UnqualifiedName__Group__0

+            {

+            pushFollow(FOLLOW_rule__UnqualifiedName__Group__0_in_ruleUnqualifiedName651);

+            rule__UnqualifiedName__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getUnqualifiedNameAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleUnqualifiedName"

+

+

+    // $ANTLR start "entryRuleTemplateBinding"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:347:1: entryRuleTemplateBinding : ruleTemplateBinding EOF ;

+    public final void entryRuleTemplateBinding() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:348:1: ( ruleTemplateBinding EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:349:1: ruleTemplateBinding EOF

+            {

+             before(grammarAccess.getTemplateBindingRule()); 

+            pushFollow(FOLLOW_ruleTemplateBinding_in_entryRuleTemplateBinding678);

+            ruleTemplateBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getTemplateBindingRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleTemplateBinding685); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleTemplateBinding"

+

+

+    // $ANTLR start "ruleTemplateBinding"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:356:1: ruleTemplateBinding : ( ( rule__TemplateBinding__Group__0 ) ) ;

+    public final void ruleTemplateBinding() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:360:2: ( ( ( rule__TemplateBinding__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:361:1: ( ( rule__TemplateBinding__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:361:1: ( ( rule__TemplateBinding__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:362:1: ( rule__TemplateBinding__Group__0 )

+            {

+             before(grammarAccess.getTemplateBindingAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:363:1: ( rule__TemplateBinding__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:363:2: rule__TemplateBinding__Group__0

+            {

+            pushFollow(FOLLOW_rule__TemplateBinding__Group__0_in_ruleTemplateBinding711);

+            rule__TemplateBinding__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getTemplateBindingAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleTemplateBinding"

+

+

+    // $ANTLR start "entryRuleNamedTemplateBinding"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:375:1: entryRuleNamedTemplateBinding : ruleNamedTemplateBinding EOF ;

+    public final void entryRuleNamedTemplateBinding() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:376:1: ( ruleNamedTemplateBinding EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:377:1: ruleNamedTemplateBinding EOF

+            {

+             before(grammarAccess.getNamedTemplateBindingRule()); 

+            pushFollow(FOLLOW_ruleNamedTemplateBinding_in_entryRuleNamedTemplateBinding738);

+            ruleNamedTemplateBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getNamedTemplateBindingRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleNamedTemplateBinding745); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleNamedTemplateBinding"

+

+

+    // $ANTLR start "ruleNamedTemplateBinding"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:384:1: ruleNamedTemplateBinding : ( ( rule__NamedTemplateBinding__Group__0 ) ) ;

+    public final void ruleNamedTemplateBinding() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:388:2: ( ( ( rule__NamedTemplateBinding__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:389:1: ( ( rule__NamedTemplateBinding__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:389:1: ( ( rule__NamedTemplateBinding__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:390:1: ( rule__NamedTemplateBinding__Group__0 )

+            {

+             before(grammarAccess.getNamedTemplateBindingAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:391:1: ( rule__NamedTemplateBinding__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:391:2: rule__NamedTemplateBinding__Group__0

+            {

+            pushFollow(FOLLOW_rule__NamedTemplateBinding__Group__0_in_ruleNamedTemplateBinding771);

+            rule__NamedTemplateBinding__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNamedTemplateBindingAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleNamedTemplateBinding"

+

+

+    // $ANTLR start "entryRuleQualifiedNameWithBinding"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:403:1: entryRuleQualifiedNameWithBinding : ruleQualifiedNameWithBinding EOF ;

+    public final void entryRuleQualifiedNameWithBinding() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:404:1: ( ruleQualifiedNameWithBinding EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:405:1: ruleQualifiedNameWithBinding EOF

+            {

+             before(grammarAccess.getQualifiedNameWithBindingRule()); 

+            pushFollow(FOLLOW_ruleQualifiedNameWithBinding_in_entryRuleQualifiedNameWithBinding798);

+            ruleQualifiedNameWithBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getQualifiedNameWithBindingRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleQualifiedNameWithBinding805); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleQualifiedNameWithBinding"

+

+

+    // $ANTLR start "ruleQualifiedNameWithBinding"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:412:1: ruleQualifiedNameWithBinding : ( ( rule__QualifiedNameWithBinding__Group__0 ) ) ;

+    public final void ruleQualifiedNameWithBinding() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:416:2: ( ( ( rule__QualifiedNameWithBinding__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:417:1: ( ( rule__QualifiedNameWithBinding__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:417:1: ( ( rule__QualifiedNameWithBinding__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:418:1: ( rule__QualifiedNameWithBinding__Group__0 )

+            {

+             before(grammarAccess.getQualifiedNameWithBindingAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:419:1: ( rule__QualifiedNameWithBinding__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:419:2: rule__QualifiedNameWithBinding__Group__0

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameWithBinding__Group__0_in_ruleQualifiedNameWithBinding831);

+            rule__QualifiedNameWithBinding__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getQualifiedNameWithBindingAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleQualifiedNameWithBinding"

+

+

+    // $ANTLR start "entryRuleTuple"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:431:1: entryRuleTuple : ruleTuple EOF ;

+    public final void entryRuleTuple() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:432:1: ( ruleTuple EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:433:1: ruleTuple EOF

+            {

+             before(grammarAccess.getTupleRule()); 

+            pushFollow(FOLLOW_ruleTuple_in_entryRuleTuple858);

+            ruleTuple();

+

+            state._fsp--;

+

+             after(grammarAccess.getTupleRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleTuple865); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleTuple"

+

+

+    // $ANTLR start "ruleTuple"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:440:1: ruleTuple : ( ( rule__Tuple__Group__0 ) ) ;

+    public final void ruleTuple() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:444:2: ( ( ( rule__Tuple__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:445:1: ( ( rule__Tuple__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:445:1: ( ( rule__Tuple__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:446:1: ( rule__Tuple__Group__0 )

+            {

+             before(grammarAccess.getTupleAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:447:1: ( rule__Tuple__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:447:2: rule__Tuple__Group__0

+            {

+            pushFollow(FOLLOW_rule__Tuple__Group__0_in_ruleTuple891);

+            rule__Tuple__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getTupleAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleTuple"

+

+

+    // $ANTLR start "entryRuleTupleElement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:459:1: entryRuleTupleElement : ruleTupleElement EOF ;

+    public final void entryRuleTupleElement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:460:1: ( ruleTupleElement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:461:1: ruleTupleElement EOF

+            {

+             before(grammarAccess.getTupleElementRule()); 

+            pushFollow(FOLLOW_ruleTupleElement_in_entryRuleTupleElement918);

+            ruleTupleElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getTupleElementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleTupleElement925); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleTupleElement"

+

+

+    // $ANTLR start "ruleTupleElement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:468:1: ruleTupleElement : ( ( rule__TupleElement__ArgumentAssignment ) ) ;

+    public final void ruleTupleElement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:472:2: ( ( ( rule__TupleElement__ArgumentAssignment ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:473:1: ( ( rule__TupleElement__ArgumentAssignment ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:473:1: ( ( rule__TupleElement__ArgumentAssignment ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:474:1: ( rule__TupleElement__ArgumentAssignment )

+            {

+             before(grammarAccess.getTupleElementAccess().getArgumentAssignment()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:475:1: ( rule__TupleElement__ArgumentAssignment )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:475:2: rule__TupleElement__ArgumentAssignment

+            {

+            pushFollow(FOLLOW_rule__TupleElement__ArgumentAssignment_in_ruleTupleElement951);

+            rule__TupleElement__ArgumentAssignment();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getTupleElementAccess().getArgumentAssignment()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleTupleElement"

+

+

+    // $ANTLR start "entryRuleExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:487:1: entryRuleExpression : ruleExpression EOF ;

+    public final void entryRuleExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:488:1: ( ruleExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:489:1: ruleExpression EOF

+            {

+             before(grammarAccess.getExpressionRule()); 

+            pushFollow(FOLLOW_ruleExpression_in_entryRuleExpression978);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleExpression985); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleExpression"

+

+

+    // $ANTLR start "ruleExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:496:1: ruleExpression : ( ruleConditionalTestExpression ) ;

+    public final void ruleExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:500:2: ( ( ruleConditionalTestExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:501:1: ( ruleConditionalTestExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:501:1: ( ruleConditionalTestExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:502:1: ruleConditionalTestExpression

+            {

+             before(grammarAccess.getExpressionAccess().getConditionalTestExpressionParserRuleCall()); 

+            pushFollow(FOLLOW_ruleConditionalTestExpression_in_ruleExpression1011);

+            ruleConditionalTestExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getExpressionAccess().getConditionalTestExpressionParserRuleCall()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleExpression"

+

+

+    // $ANTLR start "entryRuleConditionalTestExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:515:1: entryRuleConditionalTestExpression : ruleConditionalTestExpression EOF ;

+    public final void entryRuleConditionalTestExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:516:1: ( ruleConditionalTestExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:517:1: ruleConditionalTestExpression EOF

+            {

+             before(grammarAccess.getConditionalTestExpressionRule()); 

+            pushFollow(FOLLOW_ruleConditionalTestExpression_in_entryRuleConditionalTestExpression1037);

+            ruleConditionalTestExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getConditionalTestExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleConditionalTestExpression1044); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleConditionalTestExpression"

+

+

+    // $ANTLR start "ruleConditionalTestExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:524:1: ruleConditionalTestExpression : ( ( rule__ConditionalTestExpression__Group__0 ) ) ;

+    public final void ruleConditionalTestExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:528:2: ( ( ( rule__ConditionalTestExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:529:1: ( ( rule__ConditionalTestExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:529:1: ( ( rule__ConditionalTestExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:530:1: ( rule__ConditionalTestExpression__Group__0 )

+            {

+             before(grammarAccess.getConditionalTestExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:531:1: ( rule__ConditionalTestExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:531:2: rule__ConditionalTestExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__Group__0_in_ruleConditionalTestExpression1070);

+            rule__ConditionalTestExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getConditionalTestExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleConditionalTestExpression"

+

+

+    // $ANTLR start "entryRuleConditionalOrExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:543:1: entryRuleConditionalOrExpression : ruleConditionalOrExpression EOF ;

+    public final void entryRuleConditionalOrExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:544:1: ( ruleConditionalOrExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:545:1: ruleConditionalOrExpression EOF

+            {

+             before(grammarAccess.getConditionalOrExpressionRule()); 

+            pushFollow(FOLLOW_ruleConditionalOrExpression_in_entryRuleConditionalOrExpression1097);

+            ruleConditionalOrExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getConditionalOrExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleConditionalOrExpression1104); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleConditionalOrExpression"

+

+

+    // $ANTLR start "ruleConditionalOrExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:552:1: ruleConditionalOrExpression : ( ( rule__ConditionalOrExpression__Group__0 ) ) ;

+    public final void ruleConditionalOrExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:556:2: ( ( ( rule__ConditionalOrExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:557:1: ( ( rule__ConditionalOrExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:557:1: ( ( rule__ConditionalOrExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:558:1: ( rule__ConditionalOrExpression__Group__0 )

+            {

+             before(grammarAccess.getConditionalOrExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:559:1: ( rule__ConditionalOrExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:559:2: rule__ConditionalOrExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__ConditionalOrExpression__Group__0_in_ruleConditionalOrExpression1130);

+            rule__ConditionalOrExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getConditionalOrExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleConditionalOrExpression"

+

+

+    // $ANTLR start "entryRuleConditionalAndExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:571:1: entryRuleConditionalAndExpression : ruleConditionalAndExpression EOF ;

+    public final void entryRuleConditionalAndExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:572:1: ( ruleConditionalAndExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:573:1: ruleConditionalAndExpression EOF

+            {

+             before(grammarAccess.getConditionalAndExpressionRule()); 

+            pushFollow(FOLLOW_ruleConditionalAndExpression_in_entryRuleConditionalAndExpression1157);

+            ruleConditionalAndExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getConditionalAndExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleConditionalAndExpression1164); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleConditionalAndExpression"

+

+

+    // $ANTLR start "ruleConditionalAndExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:580:1: ruleConditionalAndExpression : ( ( rule__ConditionalAndExpression__Group__0 ) ) ;

+    public final void ruleConditionalAndExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:584:2: ( ( ( rule__ConditionalAndExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:585:1: ( ( rule__ConditionalAndExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:585:1: ( ( rule__ConditionalAndExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:586:1: ( rule__ConditionalAndExpression__Group__0 )

+            {

+             before(grammarAccess.getConditionalAndExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:587:1: ( rule__ConditionalAndExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:587:2: rule__ConditionalAndExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__ConditionalAndExpression__Group__0_in_ruleConditionalAndExpression1190);

+            rule__ConditionalAndExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getConditionalAndExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleConditionalAndExpression"

+

+

+    // $ANTLR start "entryRuleInclusiveOrExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:599:1: entryRuleInclusiveOrExpression : ruleInclusiveOrExpression EOF ;

+    public final void entryRuleInclusiveOrExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:600:1: ( ruleInclusiveOrExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:601:1: ruleInclusiveOrExpression EOF

+            {

+             before(grammarAccess.getInclusiveOrExpressionRule()); 

+            pushFollow(FOLLOW_ruleInclusiveOrExpression_in_entryRuleInclusiveOrExpression1217);

+            ruleInclusiveOrExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getInclusiveOrExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleInclusiveOrExpression1224); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleInclusiveOrExpression"

+

+

+    // $ANTLR start "ruleInclusiveOrExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:608:1: ruleInclusiveOrExpression : ( ( rule__InclusiveOrExpression__Group__0 ) ) ;

+    public final void ruleInclusiveOrExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:612:2: ( ( ( rule__InclusiveOrExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:613:1: ( ( rule__InclusiveOrExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:613:1: ( ( rule__InclusiveOrExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:614:1: ( rule__InclusiveOrExpression__Group__0 )

+            {

+             before(grammarAccess.getInclusiveOrExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:615:1: ( rule__InclusiveOrExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:615:2: rule__InclusiveOrExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__InclusiveOrExpression__Group__0_in_ruleInclusiveOrExpression1250);

+            rule__InclusiveOrExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInclusiveOrExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleInclusiveOrExpression"

+

+

+    // $ANTLR start "entryRuleExclusiveOrExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:627:1: entryRuleExclusiveOrExpression : ruleExclusiveOrExpression EOF ;

+    public final void entryRuleExclusiveOrExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:628:1: ( ruleExclusiveOrExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:629:1: ruleExclusiveOrExpression EOF

+            {

+             before(grammarAccess.getExclusiveOrExpressionRule()); 

+            pushFollow(FOLLOW_ruleExclusiveOrExpression_in_entryRuleExclusiveOrExpression1277);

+            ruleExclusiveOrExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getExclusiveOrExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleExclusiveOrExpression1284); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleExclusiveOrExpression"

+

+

+    // $ANTLR start "ruleExclusiveOrExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:636:1: ruleExclusiveOrExpression : ( ( rule__ExclusiveOrExpression__Group__0 ) ) ;

+    public final void ruleExclusiveOrExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:640:2: ( ( ( rule__ExclusiveOrExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:641:1: ( ( rule__ExclusiveOrExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:641:1: ( ( rule__ExclusiveOrExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:642:1: ( rule__ExclusiveOrExpression__Group__0 )

+            {

+             before(grammarAccess.getExclusiveOrExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:643:1: ( rule__ExclusiveOrExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:643:2: rule__ExclusiveOrExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__ExclusiveOrExpression__Group__0_in_ruleExclusiveOrExpression1310);

+            rule__ExclusiveOrExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getExclusiveOrExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleExclusiveOrExpression"

+

+

+    // $ANTLR start "entryRuleAndExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:655:1: entryRuleAndExpression : ruleAndExpression EOF ;

+    public final void entryRuleAndExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:656:1: ( ruleAndExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:657:1: ruleAndExpression EOF

+            {

+             before(grammarAccess.getAndExpressionRule()); 

+            pushFollow(FOLLOW_ruleAndExpression_in_entryRuleAndExpression1337);

+            ruleAndExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getAndExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleAndExpression1344); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleAndExpression"

+

+

+    // $ANTLR start "ruleAndExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:664:1: ruleAndExpression : ( ( rule__AndExpression__Group__0 ) ) ;

+    public final void ruleAndExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:668:2: ( ( ( rule__AndExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:669:1: ( ( rule__AndExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:669:1: ( ( rule__AndExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:670:1: ( rule__AndExpression__Group__0 )

+            {

+             before(grammarAccess.getAndExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:671:1: ( rule__AndExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:671:2: rule__AndExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__AndExpression__Group__0_in_ruleAndExpression1370);

+            rule__AndExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAndExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleAndExpression"

+

+

+    // $ANTLR start "entryRuleEqualityExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:683:1: entryRuleEqualityExpression : ruleEqualityExpression EOF ;

+    public final void entryRuleEqualityExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:684:1: ( ruleEqualityExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:685:1: ruleEqualityExpression EOF

+            {

+             before(grammarAccess.getEqualityExpressionRule()); 

+            pushFollow(FOLLOW_ruleEqualityExpression_in_entryRuleEqualityExpression1397);

+            ruleEqualityExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getEqualityExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleEqualityExpression1404); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleEqualityExpression"

+

+

+    // $ANTLR start "ruleEqualityExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:692:1: ruleEqualityExpression : ( ( rule__EqualityExpression__Group__0 ) ) ;

+    public final void ruleEqualityExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:696:2: ( ( ( rule__EqualityExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:697:1: ( ( rule__EqualityExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:697:1: ( ( rule__EqualityExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:698:1: ( rule__EqualityExpression__Group__0 )

+            {

+             before(grammarAccess.getEqualityExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:699:1: ( rule__EqualityExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:699:2: rule__EqualityExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__EqualityExpression__Group__0_in_ruleEqualityExpression1430);

+            rule__EqualityExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getEqualityExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleEqualityExpression"

+

+

+    // $ANTLR start "entryRuleClassificationExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:711:1: entryRuleClassificationExpression : ruleClassificationExpression EOF ;

+    public final void entryRuleClassificationExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:712:1: ( ruleClassificationExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:713:1: ruleClassificationExpression EOF

+            {

+             before(grammarAccess.getClassificationExpressionRule()); 

+            pushFollow(FOLLOW_ruleClassificationExpression_in_entryRuleClassificationExpression1457);

+            ruleClassificationExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassificationExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleClassificationExpression1464); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleClassificationExpression"

+

+

+    // $ANTLR start "ruleClassificationExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:720:1: ruleClassificationExpression : ( ( rule__ClassificationExpression__Group__0 ) ) ;

+    public final void ruleClassificationExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:724:2: ( ( ( rule__ClassificationExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:725:1: ( ( rule__ClassificationExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:725:1: ( ( rule__ClassificationExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:726:1: ( rule__ClassificationExpression__Group__0 )

+            {

+             before(grammarAccess.getClassificationExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:727:1: ( rule__ClassificationExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:727:2: rule__ClassificationExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__ClassificationExpression__Group__0_in_ruleClassificationExpression1490);

+            rule__ClassificationExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassificationExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleClassificationExpression"

+

+

+    // $ANTLR start "entryRuleRelationalExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:739:1: entryRuleRelationalExpression : ruleRelationalExpression EOF ;

+    public final void entryRuleRelationalExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:740:1: ( ruleRelationalExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:741:1: ruleRelationalExpression EOF

+            {

+             before(grammarAccess.getRelationalExpressionRule()); 

+            pushFollow(FOLLOW_ruleRelationalExpression_in_entryRuleRelationalExpression1517);

+            ruleRelationalExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getRelationalExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleRelationalExpression1524); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleRelationalExpression"

+

+

+    // $ANTLR start "ruleRelationalExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:748:1: ruleRelationalExpression : ( ( rule__RelationalExpression__Group__0 ) ) ;

+    public final void ruleRelationalExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:752:2: ( ( ( rule__RelationalExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:753:1: ( ( rule__RelationalExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:753:1: ( ( rule__RelationalExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:754:1: ( rule__RelationalExpression__Group__0 )

+            {

+             before(grammarAccess.getRelationalExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:755:1: ( rule__RelationalExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:755:2: rule__RelationalExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__RelationalExpression__Group__0_in_ruleRelationalExpression1550);

+            rule__RelationalExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getRelationalExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleRelationalExpression"

+

+

+    // $ANTLR start "entryRuleShiftExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:767:1: entryRuleShiftExpression : ruleShiftExpression EOF ;

+    public final void entryRuleShiftExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:768:1: ( ruleShiftExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:769:1: ruleShiftExpression EOF

+            {

+             before(grammarAccess.getShiftExpressionRule()); 

+            pushFollow(FOLLOW_ruleShiftExpression_in_entryRuleShiftExpression1577);

+            ruleShiftExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getShiftExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleShiftExpression1584); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleShiftExpression"

+

+

+    // $ANTLR start "ruleShiftExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:776:1: ruleShiftExpression : ( ( rule__ShiftExpression__Group__0 ) ) ;

+    public final void ruleShiftExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:780:2: ( ( ( rule__ShiftExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:781:1: ( ( rule__ShiftExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:781:1: ( ( rule__ShiftExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:782:1: ( rule__ShiftExpression__Group__0 )

+            {

+             before(grammarAccess.getShiftExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:783:1: ( rule__ShiftExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:783:2: rule__ShiftExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__ShiftExpression__Group__0_in_ruleShiftExpression1610);

+            rule__ShiftExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getShiftExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleShiftExpression"

+

+

+    // $ANTLR start "entryRuleAdditiveExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:795:1: entryRuleAdditiveExpression : ruleAdditiveExpression EOF ;

+    public final void entryRuleAdditiveExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:796:1: ( ruleAdditiveExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:797:1: ruleAdditiveExpression EOF

+            {

+             before(grammarAccess.getAdditiveExpressionRule()); 

+            pushFollow(FOLLOW_ruleAdditiveExpression_in_entryRuleAdditiveExpression1637);

+            ruleAdditiveExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getAdditiveExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleAdditiveExpression1644); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleAdditiveExpression"

+

+

+    // $ANTLR start "ruleAdditiveExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:804:1: ruleAdditiveExpression : ( ( rule__AdditiveExpression__Group__0 ) ) ;

+    public final void ruleAdditiveExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:808:2: ( ( ( rule__AdditiveExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:809:1: ( ( rule__AdditiveExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:809:1: ( ( rule__AdditiveExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:810:1: ( rule__AdditiveExpression__Group__0 )

+            {

+             before(grammarAccess.getAdditiveExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:811:1: ( rule__AdditiveExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:811:2: rule__AdditiveExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__AdditiveExpression__Group__0_in_ruleAdditiveExpression1670);

+            rule__AdditiveExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAdditiveExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleAdditiveExpression"

+

+

+    // $ANTLR start "entryRuleMultiplicativeExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:823:1: entryRuleMultiplicativeExpression : ruleMultiplicativeExpression EOF ;

+    public final void entryRuleMultiplicativeExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:824:1: ( ruleMultiplicativeExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:825:1: ruleMultiplicativeExpression EOF

+            {

+             before(grammarAccess.getMultiplicativeExpressionRule()); 

+            pushFollow(FOLLOW_ruleMultiplicativeExpression_in_entryRuleMultiplicativeExpression1697);

+            ruleMultiplicativeExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getMultiplicativeExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleMultiplicativeExpression1704); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleMultiplicativeExpression"

+

+

+    // $ANTLR start "ruleMultiplicativeExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:832:1: ruleMultiplicativeExpression : ( ( rule__MultiplicativeExpression__Group__0 ) ) ;

+    public final void ruleMultiplicativeExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:836:2: ( ( ( rule__MultiplicativeExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:837:1: ( ( rule__MultiplicativeExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:837:1: ( ( rule__MultiplicativeExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:838:1: ( rule__MultiplicativeExpression__Group__0 )

+            {

+             before(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:839:1: ( rule__MultiplicativeExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:839:2: rule__MultiplicativeExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__MultiplicativeExpression__Group__0_in_ruleMultiplicativeExpression1730);

+            rule__MultiplicativeExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleMultiplicativeExpression"

+

+

+    // $ANTLR start "entryRuleUnaryExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:851:1: entryRuleUnaryExpression : ruleUnaryExpression EOF ;

+    public final void entryRuleUnaryExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:852:1: ( ruleUnaryExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:853:1: ruleUnaryExpression EOF

+            {

+             before(grammarAccess.getUnaryExpressionRule()); 

+            pushFollow(FOLLOW_ruleUnaryExpression_in_entryRuleUnaryExpression1757);

+            ruleUnaryExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getUnaryExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleUnaryExpression1764); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleUnaryExpression"

+

+

+    // $ANTLR start "ruleUnaryExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:860:1: ruleUnaryExpression : ( ( rule__UnaryExpression__Group__0 ) ) ;

+    public final void ruleUnaryExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:864:2: ( ( ( rule__UnaryExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:865:1: ( ( rule__UnaryExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:865:1: ( ( rule__UnaryExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:866:1: ( rule__UnaryExpression__Group__0 )

+            {

+             before(grammarAccess.getUnaryExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:867:1: ( rule__UnaryExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:867:2: rule__UnaryExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__UnaryExpression__Group__0_in_ruleUnaryExpression1790);

+            rule__UnaryExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getUnaryExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleUnaryExpression"

+

+

+    // $ANTLR start "entryRulePrimaryExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:879:1: entryRulePrimaryExpression : rulePrimaryExpression EOF ;

+    public final void entryRulePrimaryExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:880:1: ( rulePrimaryExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:881:1: rulePrimaryExpression EOF

+            {

+             before(grammarAccess.getPrimaryExpressionRule()); 

+            pushFollow(FOLLOW_rulePrimaryExpression_in_entryRulePrimaryExpression1817);

+            rulePrimaryExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getPrimaryExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRulePrimaryExpression1824); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRulePrimaryExpression"

+

+

+    // $ANTLR start "rulePrimaryExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:888:1: rulePrimaryExpression : ( ( rule__PrimaryExpression__PrefixAssignment ) ) ;

+    public final void rulePrimaryExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:892:2: ( ( ( rule__PrimaryExpression__PrefixAssignment ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:893:1: ( ( rule__PrimaryExpression__PrefixAssignment ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:893:1: ( ( rule__PrimaryExpression__PrefixAssignment ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:894:1: ( rule__PrimaryExpression__PrefixAssignment )

+            {

+             before(grammarAccess.getPrimaryExpressionAccess().getPrefixAssignment()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:895:1: ( rule__PrimaryExpression__PrefixAssignment )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:895:2: rule__PrimaryExpression__PrefixAssignment

+            {

+            pushFollow(FOLLOW_rule__PrimaryExpression__PrefixAssignment_in_rulePrimaryExpression1850);

+            rule__PrimaryExpression__PrefixAssignment();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getPrimaryExpressionAccess().getPrefixAssignment()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rulePrimaryExpression"

+

+

+    // $ANTLR start "entryRuleSuffixExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:907:1: entryRuleSuffixExpression : ruleSuffixExpression EOF ;

+    public final void entryRuleSuffixExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:908:1: ( ruleSuffixExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:909:1: ruleSuffixExpression EOF

+            {

+             before(grammarAccess.getSuffixExpressionRule()); 

+            pushFollow(FOLLOW_ruleSuffixExpression_in_entryRuleSuffixExpression1877);

+            ruleSuffixExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSuffixExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSuffixExpression1884); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSuffixExpression"

+

+

+    // $ANTLR start "ruleSuffixExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:916:1: ruleSuffixExpression : ( ( rule__SuffixExpression__Alternatives ) ) ;

+    public final void ruleSuffixExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:920:2: ( ( ( rule__SuffixExpression__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:921:1: ( ( rule__SuffixExpression__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:921:1: ( ( rule__SuffixExpression__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:922:1: ( rule__SuffixExpression__Alternatives )

+            {

+             before(grammarAccess.getSuffixExpressionAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:923:1: ( rule__SuffixExpression__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:923:2: rule__SuffixExpression__Alternatives

+            {

+            pushFollow(FOLLOW_rule__SuffixExpression__Alternatives_in_ruleSuffixExpression1910);

+            rule__SuffixExpression__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSuffixExpressionAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSuffixExpression"

+

+

+    // $ANTLR start "entryRuleOperationCallExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:935:1: entryRuleOperationCallExpression : ruleOperationCallExpression EOF ;

+    public final void entryRuleOperationCallExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:936:1: ( ruleOperationCallExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:937:1: ruleOperationCallExpression EOF

+            {

+             before(grammarAccess.getOperationCallExpressionRule()); 

+            pushFollow(FOLLOW_ruleOperationCallExpression_in_entryRuleOperationCallExpression1937);

+            ruleOperationCallExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getOperationCallExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleOperationCallExpression1944); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleOperationCallExpression"

+

+

+    // $ANTLR start "ruleOperationCallExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:944:1: ruleOperationCallExpression : ( ( rule__OperationCallExpression__Group__0 ) ) ;

+    public final void ruleOperationCallExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:948:2: ( ( ( rule__OperationCallExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:949:1: ( ( rule__OperationCallExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:949:1: ( ( rule__OperationCallExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:950:1: ( rule__OperationCallExpression__Group__0 )

+            {

+             before(grammarAccess.getOperationCallExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:951:1: ( rule__OperationCallExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:951:2: rule__OperationCallExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__OperationCallExpression__Group__0_in_ruleOperationCallExpression1970);

+            rule__OperationCallExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getOperationCallExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleOperationCallExpression"

+

+

+    // $ANTLR start "entryRulePropertyCallExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:963:1: entryRulePropertyCallExpression : rulePropertyCallExpression EOF ;

+    public final void entryRulePropertyCallExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:964:1: ( rulePropertyCallExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:965:1: rulePropertyCallExpression EOF

+            {

+             before(grammarAccess.getPropertyCallExpressionRule()); 

+            pushFollow(FOLLOW_rulePropertyCallExpression_in_entryRulePropertyCallExpression1997);

+            rulePropertyCallExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getPropertyCallExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRulePropertyCallExpression2004); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRulePropertyCallExpression"

+

+

+    // $ANTLR start "rulePropertyCallExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:972:1: rulePropertyCallExpression : ( ( rule__PropertyCallExpression__Group__0 ) ) ;

+    public final void rulePropertyCallExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:976:2: ( ( ( rule__PropertyCallExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:977:1: ( ( rule__PropertyCallExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:977:1: ( ( rule__PropertyCallExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:978:1: ( rule__PropertyCallExpression__Group__0 )

+            {

+             before(grammarAccess.getPropertyCallExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:979:1: ( rule__PropertyCallExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:979:2: rule__PropertyCallExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__PropertyCallExpression__Group__0_in_rulePropertyCallExpression2030);

+            rule__PropertyCallExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getPropertyCallExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rulePropertyCallExpression"

+

+

+    // $ANTLR start "entryRuleLinkOperationExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:991:1: entryRuleLinkOperationExpression : ruleLinkOperationExpression EOF ;

+    public final void entryRuleLinkOperationExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:992:1: ( ruleLinkOperationExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:993:1: ruleLinkOperationExpression EOF

+            {

+             before(grammarAccess.getLinkOperationExpressionRule()); 

+            pushFollow(FOLLOW_ruleLinkOperationExpression_in_entryRuleLinkOperationExpression2057);

+            ruleLinkOperationExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getLinkOperationExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleLinkOperationExpression2064); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleLinkOperationExpression"

+

+

+    // $ANTLR start "ruleLinkOperationExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1000:1: ruleLinkOperationExpression : ( ( rule__LinkOperationExpression__Group__0 ) ) ;

+    public final void ruleLinkOperationExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1004:2: ( ( ( rule__LinkOperationExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1005:1: ( ( rule__LinkOperationExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1005:1: ( ( rule__LinkOperationExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1006:1: ( rule__LinkOperationExpression__Group__0 )

+            {

+             before(grammarAccess.getLinkOperationExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1007:1: ( rule__LinkOperationExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1007:2: rule__LinkOperationExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__LinkOperationExpression__Group__0_in_ruleLinkOperationExpression2090);

+            rule__LinkOperationExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLinkOperationExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleLinkOperationExpression"

+

+

+    // $ANTLR start "entryRuleLinkOperationTuple"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1019:1: entryRuleLinkOperationTuple : ruleLinkOperationTuple EOF ;

+    public final void entryRuleLinkOperationTuple() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1020:1: ( ruleLinkOperationTuple EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1021:1: ruleLinkOperationTuple EOF

+            {

+             before(grammarAccess.getLinkOperationTupleRule()); 

+            pushFollow(FOLLOW_ruleLinkOperationTuple_in_entryRuleLinkOperationTuple2117);

+            ruleLinkOperationTuple();

+

+            state._fsp--;

+

+             after(grammarAccess.getLinkOperationTupleRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleLinkOperationTuple2124); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleLinkOperationTuple"

+

+

+    // $ANTLR start "ruleLinkOperationTuple"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1028:1: ruleLinkOperationTuple : ( ( rule__LinkOperationTuple__Group__0 ) ) ;

+    public final void ruleLinkOperationTuple() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1032:2: ( ( ( rule__LinkOperationTuple__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1033:1: ( ( rule__LinkOperationTuple__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1033:1: ( ( rule__LinkOperationTuple__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1034:1: ( rule__LinkOperationTuple__Group__0 )

+            {

+             before(grammarAccess.getLinkOperationTupleAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1035:1: ( rule__LinkOperationTuple__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1035:2: rule__LinkOperationTuple__Group__0

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTuple__Group__0_in_ruleLinkOperationTuple2150);

+            rule__LinkOperationTuple__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLinkOperationTupleAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleLinkOperationTuple"

+

+

+    // $ANTLR start "entryRuleLinkOperationTupleElement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1047:1: entryRuleLinkOperationTupleElement : ruleLinkOperationTupleElement EOF ;

+    public final void entryRuleLinkOperationTupleElement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1048:1: ( ruleLinkOperationTupleElement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1049:1: ruleLinkOperationTupleElement EOF

+            {

+             before(grammarAccess.getLinkOperationTupleElementRule()); 

+            pushFollow(FOLLOW_ruleLinkOperationTupleElement_in_entryRuleLinkOperationTupleElement2177);

+            ruleLinkOperationTupleElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getLinkOperationTupleElementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleLinkOperationTupleElement2184); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleLinkOperationTupleElement"

+

+

+    // $ANTLR start "ruleLinkOperationTupleElement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1056:1: ruleLinkOperationTupleElement : ( ( rule__LinkOperationTupleElement__Group__0 ) ) ;

+    public final void ruleLinkOperationTupleElement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1060:2: ( ( ( rule__LinkOperationTupleElement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1061:1: ( ( rule__LinkOperationTupleElement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1061:1: ( ( rule__LinkOperationTupleElement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1062:1: ( rule__LinkOperationTupleElement__Group__0 )

+            {

+             before(grammarAccess.getLinkOperationTupleElementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1063:1: ( rule__LinkOperationTupleElement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1063:2: rule__LinkOperationTupleElement__Group__0

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group__0_in_ruleLinkOperationTupleElement2210);

+            rule__LinkOperationTupleElement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLinkOperationTupleElementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleLinkOperationTupleElement"

+

+

+    // $ANTLR start "entryRuleSequenceOperationExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1075:1: entryRuleSequenceOperationExpression : ruleSequenceOperationExpression EOF ;

+    public final void entryRuleSequenceOperationExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1076:1: ( ruleSequenceOperationExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1077:1: ruleSequenceOperationExpression EOF

+            {

+             before(grammarAccess.getSequenceOperationExpressionRule()); 

+            pushFollow(FOLLOW_ruleSequenceOperationExpression_in_entryRuleSequenceOperationExpression2237);

+            ruleSequenceOperationExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceOperationExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSequenceOperationExpression2244); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSequenceOperationExpression"

+

+

+    // $ANTLR start "ruleSequenceOperationExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1084:1: ruleSequenceOperationExpression : ( ( rule__SequenceOperationExpression__Group__0 ) ) ;

+    public final void ruleSequenceOperationExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1088:2: ( ( ( rule__SequenceOperationExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1089:1: ( ( rule__SequenceOperationExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1089:1: ( ( rule__SequenceOperationExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1090:1: ( rule__SequenceOperationExpression__Group__0 )

+            {

+             before(grammarAccess.getSequenceOperationExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1091:1: ( rule__SequenceOperationExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1091:2: rule__SequenceOperationExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__SequenceOperationExpression__Group__0_in_ruleSequenceOperationExpression2270);

+            rule__SequenceOperationExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceOperationExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSequenceOperationExpression"

+

+

+    // $ANTLR start "entryRuleSequenceReductionExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1103:1: entryRuleSequenceReductionExpression : ruleSequenceReductionExpression EOF ;

+    public final void entryRuleSequenceReductionExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1104:1: ( ruleSequenceReductionExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1105:1: ruleSequenceReductionExpression EOF

+            {

+             before(grammarAccess.getSequenceReductionExpressionRule()); 

+            pushFollow(FOLLOW_ruleSequenceReductionExpression_in_entryRuleSequenceReductionExpression2297);

+            ruleSequenceReductionExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceReductionExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSequenceReductionExpression2304); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSequenceReductionExpression"

+

+

+    // $ANTLR start "ruleSequenceReductionExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1112:1: ruleSequenceReductionExpression : ( ( rule__SequenceReductionExpression__Group__0 ) ) ;

+    public final void ruleSequenceReductionExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1116:2: ( ( ( rule__SequenceReductionExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1117:1: ( ( rule__SequenceReductionExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1117:1: ( ( rule__SequenceReductionExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1118:1: ( rule__SequenceReductionExpression__Group__0 )

+            {

+             before(grammarAccess.getSequenceReductionExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1119:1: ( rule__SequenceReductionExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1119:2: rule__SequenceReductionExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__SequenceReductionExpression__Group__0_in_ruleSequenceReductionExpression2330);

+            rule__SequenceReductionExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceReductionExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSequenceReductionExpression"

+

+

+    // $ANTLR start "entryRuleSequenceExpansionExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1131:1: entryRuleSequenceExpansionExpression : ruleSequenceExpansionExpression EOF ;

+    public final void entryRuleSequenceExpansionExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1132:1: ( ruleSequenceExpansionExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1133:1: ruleSequenceExpansionExpression EOF

+            {

+             before(grammarAccess.getSequenceExpansionExpressionRule()); 

+            pushFollow(FOLLOW_ruleSequenceExpansionExpression_in_entryRuleSequenceExpansionExpression2357);

+            ruleSequenceExpansionExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceExpansionExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSequenceExpansionExpression2364); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSequenceExpansionExpression"

+

+

+    // $ANTLR start "ruleSequenceExpansionExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1140:1: ruleSequenceExpansionExpression : ( ( rule__SequenceExpansionExpression__Alternatives ) ) ;

+    public final void ruleSequenceExpansionExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1144:2: ( ( ( rule__SequenceExpansionExpression__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1145:1: ( ( rule__SequenceExpansionExpression__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1145:1: ( ( rule__SequenceExpansionExpression__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1146:1: ( rule__SequenceExpansionExpression__Alternatives )

+            {

+             before(grammarAccess.getSequenceExpansionExpressionAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1147:1: ( rule__SequenceExpansionExpression__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1147:2: rule__SequenceExpansionExpression__Alternatives

+            {

+            pushFollow(FOLLOW_rule__SequenceExpansionExpression__Alternatives_in_ruleSequenceExpansionExpression2390);

+            rule__SequenceExpansionExpression__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceExpansionExpressionAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSequenceExpansionExpression"

+

+

+    // $ANTLR start "entryRuleSelectOrRejectOperation"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1159:1: entryRuleSelectOrRejectOperation : ruleSelectOrRejectOperation EOF ;

+    public final void entryRuleSelectOrRejectOperation() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1160:1: ( ruleSelectOrRejectOperation EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1161:1: ruleSelectOrRejectOperation EOF

+            {

+             before(grammarAccess.getSelectOrRejectOperationRule()); 

+            pushFollow(FOLLOW_ruleSelectOrRejectOperation_in_entryRuleSelectOrRejectOperation2417);

+            ruleSelectOrRejectOperation();

+

+            state._fsp--;

+

+             after(grammarAccess.getSelectOrRejectOperationRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSelectOrRejectOperation2424); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSelectOrRejectOperation"

+

+

+    // $ANTLR start "ruleSelectOrRejectOperation"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1168:1: ruleSelectOrRejectOperation : ( ( rule__SelectOrRejectOperation__Group__0 ) ) ;

+    public final void ruleSelectOrRejectOperation() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1172:2: ( ( ( rule__SelectOrRejectOperation__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1173:1: ( ( rule__SelectOrRejectOperation__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1173:1: ( ( rule__SelectOrRejectOperation__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1174:1: ( rule__SelectOrRejectOperation__Group__0 )

+            {

+             before(grammarAccess.getSelectOrRejectOperationAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1175:1: ( rule__SelectOrRejectOperation__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1175:2: rule__SelectOrRejectOperation__Group__0

+            {

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__0_in_ruleSelectOrRejectOperation2450);

+            rule__SelectOrRejectOperation__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSelectOrRejectOperationAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSelectOrRejectOperation"

+

+

+    // $ANTLR start "entryRuleCollectOrIterateOperation"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1187:1: entryRuleCollectOrIterateOperation : ruleCollectOrIterateOperation EOF ;

+    public final void entryRuleCollectOrIterateOperation() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1188:1: ( ruleCollectOrIterateOperation EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1189:1: ruleCollectOrIterateOperation EOF

+            {

+             before(grammarAccess.getCollectOrIterateOperationRule()); 

+            pushFollow(FOLLOW_ruleCollectOrIterateOperation_in_entryRuleCollectOrIterateOperation2477);

+            ruleCollectOrIterateOperation();

+

+            state._fsp--;

+

+             after(grammarAccess.getCollectOrIterateOperationRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleCollectOrIterateOperation2484); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleCollectOrIterateOperation"

+

+

+    // $ANTLR start "ruleCollectOrIterateOperation"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1196:1: ruleCollectOrIterateOperation : ( ( rule__CollectOrIterateOperation__Group__0 ) ) ;

+    public final void ruleCollectOrIterateOperation() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1200:2: ( ( ( rule__CollectOrIterateOperation__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1201:1: ( ( rule__CollectOrIterateOperation__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1201:1: ( ( rule__CollectOrIterateOperation__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1202:1: ( rule__CollectOrIterateOperation__Group__0 )

+            {

+             before(grammarAccess.getCollectOrIterateOperationAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1203:1: ( rule__CollectOrIterateOperation__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1203:2: rule__CollectOrIterateOperation__Group__0

+            {

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__0_in_ruleCollectOrIterateOperation2510);

+            rule__CollectOrIterateOperation__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getCollectOrIterateOperationAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleCollectOrIterateOperation"

+

+

+    // $ANTLR start "entryRuleForAllOrExistsOrOneOperation"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1215:1: entryRuleForAllOrExistsOrOneOperation : ruleForAllOrExistsOrOneOperation EOF ;

+    public final void entryRuleForAllOrExistsOrOneOperation() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1216:1: ( ruleForAllOrExistsOrOneOperation EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1217:1: ruleForAllOrExistsOrOneOperation EOF

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperationRule()); 

+            pushFollow(FOLLOW_ruleForAllOrExistsOrOneOperation_in_entryRuleForAllOrExistsOrOneOperation2537);

+            ruleForAllOrExistsOrOneOperation();

+

+            state._fsp--;

+

+             after(grammarAccess.getForAllOrExistsOrOneOperationRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleForAllOrExistsOrOneOperation2544); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleForAllOrExistsOrOneOperation"

+

+

+    // $ANTLR start "ruleForAllOrExistsOrOneOperation"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1224:1: ruleForAllOrExistsOrOneOperation : ( ( rule__ForAllOrExistsOrOneOperation__Group__0 ) ) ;

+    public final void ruleForAllOrExistsOrOneOperation() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1228:2: ( ( ( rule__ForAllOrExistsOrOneOperation__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1229:1: ( ( rule__ForAllOrExistsOrOneOperation__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1229:1: ( ( rule__ForAllOrExistsOrOneOperation__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1230:1: ( rule__ForAllOrExistsOrOneOperation__Group__0 )

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1231:1: ( rule__ForAllOrExistsOrOneOperation__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1231:2: rule__ForAllOrExistsOrOneOperation__Group__0

+            {

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__0_in_ruleForAllOrExistsOrOneOperation2570);

+            rule__ForAllOrExistsOrOneOperation__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleForAllOrExistsOrOneOperation"

+

+

+    // $ANTLR start "entryRuleIsUniqueOperation"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1243:1: entryRuleIsUniqueOperation : ruleIsUniqueOperation EOF ;

+    public final void entryRuleIsUniqueOperation() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1244:1: ( ruleIsUniqueOperation EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1245:1: ruleIsUniqueOperation EOF

+            {

+             before(grammarAccess.getIsUniqueOperationRule()); 

+            pushFollow(FOLLOW_ruleIsUniqueOperation_in_entryRuleIsUniqueOperation2597);

+            ruleIsUniqueOperation();

+

+            state._fsp--;

+

+             after(grammarAccess.getIsUniqueOperationRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleIsUniqueOperation2604); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleIsUniqueOperation"

+

+

+    // $ANTLR start "ruleIsUniqueOperation"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1252:1: ruleIsUniqueOperation : ( ( rule__IsUniqueOperation__Group__0 ) ) ;

+    public final void ruleIsUniqueOperation() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1256:2: ( ( ( rule__IsUniqueOperation__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1257:1: ( ( rule__IsUniqueOperation__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1257:1: ( ( rule__IsUniqueOperation__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1258:1: ( rule__IsUniqueOperation__Group__0 )

+            {

+             before(grammarAccess.getIsUniqueOperationAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1259:1: ( rule__IsUniqueOperation__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1259:2: rule__IsUniqueOperation__Group__0

+            {

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__0_in_ruleIsUniqueOperation2630);

+            rule__IsUniqueOperation__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getIsUniqueOperationAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleIsUniqueOperation"

+

+

+    // $ANTLR start "entryRuleValueSpecification"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1271:1: entryRuleValueSpecification : ruleValueSpecification EOF ;

+    public final void entryRuleValueSpecification() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1272:1: ( ruleValueSpecification EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1273:1: ruleValueSpecification EOF

+            {

+             before(grammarAccess.getValueSpecificationRule()); 

+            pushFollow(FOLLOW_ruleValueSpecification_in_entryRuleValueSpecification2657);

+            ruleValueSpecification();

+

+            state._fsp--;

+

+             after(grammarAccess.getValueSpecificationRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleValueSpecification2664); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleValueSpecification"

+

+

+    // $ANTLR start "ruleValueSpecification"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1280:1: ruleValueSpecification : ( ( rule__ValueSpecification__Alternatives ) ) ;

+    public final void ruleValueSpecification() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1284:2: ( ( ( rule__ValueSpecification__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1285:1: ( ( rule__ValueSpecification__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1285:1: ( ( rule__ValueSpecification__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1286:1: ( rule__ValueSpecification__Alternatives )

+            {

+             before(grammarAccess.getValueSpecificationAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1287:1: ( rule__ValueSpecification__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1287:2: rule__ValueSpecification__Alternatives

+            {

+            pushFollow(FOLLOW_rule__ValueSpecification__Alternatives_in_ruleValueSpecification2690);

+            rule__ValueSpecification__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getValueSpecificationAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleValueSpecification"

+

+

+    // $ANTLR start "entryRuleNonLiteralValueSpecification"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1299:1: entryRuleNonLiteralValueSpecification : ruleNonLiteralValueSpecification EOF ;

+    public final void entryRuleNonLiteralValueSpecification() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1300:1: ( ruleNonLiteralValueSpecification EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1301:1: ruleNonLiteralValueSpecification EOF

+            {

+             before(grammarAccess.getNonLiteralValueSpecificationRule()); 

+            pushFollow(FOLLOW_ruleNonLiteralValueSpecification_in_entryRuleNonLiteralValueSpecification2717);

+            ruleNonLiteralValueSpecification();

+

+            state._fsp--;

+

+             after(grammarAccess.getNonLiteralValueSpecificationRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleNonLiteralValueSpecification2724); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleNonLiteralValueSpecification"

+

+

+    // $ANTLR start "ruleNonLiteralValueSpecification"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1308:1: ruleNonLiteralValueSpecification : ( ( rule__NonLiteralValueSpecification__Alternatives ) ) ;

+    public final void ruleNonLiteralValueSpecification() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1312:2: ( ( ( rule__NonLiteralValueSpecification__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1313:1: ( ( rule__NonLiteralValueSpecification__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1313:1: ( ( rule__NonLiteralValueSpecification__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1314:1: ( rule__NonLiteralValueSpecification__Alternatives )

+            {

+             before(grammarAccess.getNonLiteralValueSpecificationAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1315:1: ( rule__NonLiteralValueSpecification__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1315:2: rule__NonLiteralValueSpecification__Alternatives

+            {

+            pushFollow(FOLLOW_rule__NonLiteralValueSpecification__Alternatives_in_ruleNonLiteralValueSpecification2750);

+            rule__NonLiteralValueSpecification__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNonLiteralValueSpecificationAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleNonLiteralValueSpecification"

+

+

+    // $ANTLR start "entryRuleParenthesizedExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1327:1: entryRuleParenthesizedExpression : ruleParenthesizedExpression EOF ;

+    public final void entryRuleParenthesizedExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1328:1: ( ruleParenthesizedExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1329:1: ruleParenthesizedExpression EOF

+            {

+             before(grammarAccess.getParenthesizedExpressionRule()); 

+            pushFollow(FOLLOW_ruleParenthesizedExpression_in_entryRuleParenthesizedExpression2777);

+            ruleParenthesizedExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getParenthesizedExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleParenthesizedExpression2784); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleParenthesizedExpression"

+

+

+    // $ANTLR start "ruleParenthesizedExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1336:1: ruleParenthesizedExpression : ( ( rule__ParenthesizedExpression__Group__0 ) ) ;

+    public final void ruleParenthesizedExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1340:2: ( ( ( rule__ParenthesizedExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1341:1: ( ( rule__ParenthesizedExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1341:1: ( ( rule__ParenthesizedExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1342:1: ( rule__ParenthesizedExpression__Group__0 )

+            {

+             before(grammarAccess.getParenthesizedExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1343:1: ( rule__ParenthesizedExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1343:2: rule__ParenthesizedExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__ParenthesizedExpression__Group__0_in_ruleParenthesizedExpression2810);

+            rule__ParenthesizedExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getParenthesizedExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleParenthesizedExpression"

+

+

+    // $ANTLR start "entryRuleNullExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1355:1: entryRuleNullExpression : ruleNullExpression EOF ;

+    public final void entryRuleNullExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1356:1: ( ruleNullExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1357:1: ruleNullExpression EOF

+            {

+             before(grammarAccess.getNullExpressionRule()); 

+            pushFollow(FOLLOW_ruleNullExpression_in_entryRuleNullExpression2837);

+            ruleNullExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getNullExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleNullExpression2844); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleNullExpression"

+

+

+    // $ANTLR start "ruleNullExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1364:1: ruleNullExpression : ( ( rule__NullExpression__Group__0 ) ) ;

+    public final void ruleNullExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1368:2: ( ( ( rule__NullExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1369:1: ( ( rule__NullExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1369:1: ( ( rule__NullExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1370:1: ( rule__NullExpression__Group__0 )

+            {

+             before(grammarAccess.getNullExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1371:1: ( rule__NullExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1371:2: rule__NullExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__NullExpression__Group__0_in_ruleNullExpression2870);

+            rule__NullExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNullExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleNullExpression"

+

+

+    // $ANTLR start "entryRuleThisExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1383:1: entryRuleThisExpression : ruleThisExpression EOF ;

+    public final void entryRuleThisExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1384:1: ( ruleThisExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1385:1: ruleThisExpression EOF

+            {

+             before(grammarAccess.getThisExpressionRule()); 

+            pushFollow(FOLLOW_ruleThisExpression_in_entryRuleThisExpression2897);

+            ruleThisExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getThisExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleThisExpression2904); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleThisExpression"

+

+

+    // $ANTLR start "ruleThisExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1392:1: ruleThisExpression : ( ( rule__ThisExpression__Group__0 ) ) ;

+    public final void ruleThisExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1396:2: ( ( ( rule__ThisExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1397:1: ( ( rule__ThisExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1397:1: ( ( rule__ThisExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1398:1: ( rule__ThisExpression__Group__0 )

+            {

+             before(grammarAccess.getThisExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1399:1: ( rule__ThisExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1399:2: rule__ThisExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__ThisExpression__Group__0_in_ruleThisExpression2930);

+            rule__ThisExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getThisExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleThisExpression"

+

+

+    // $ANTLR start "entryRuleSuperInvocationExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1411:1: entryRuleSuperInvocationExpression : ruleSuperInvocationExpression EOF ;

+    public final void entryRuleSuperInvocationExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1412:1: ( ruleSuperInvocationExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1413:1: ruleSuperInvocationExpression EOF

+            {

+             before(grammarAccess.getSuperInvocationExpressionRule()); 

+            pushFollow(FOLLOW_ruleSuperInvocationExpression_in_entryRuleSuperInvocationExpression2957);

+            ruleSuperInvocationExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSuperInvocationExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSuperInvocationExpression2964); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSuperInvocationExpression"

+

+

+    // $ANTLR start "ruleSuperInvocationExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1420:1: ruleSuperInvocationExpression : ( ( rule__SuperInvocationExpression__Group__0 ) ) ;

+    public final void ruleSuperInvocationExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1424:2: ( ( ( rule__SuperInvocationExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1425:1: ( ( rule__SuperInvocationExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1425:1: ( ( rule__SuperInvocationExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1426:1: ( rule__SuperInvocationExpression__Group__0 )

+            {

+             before(grammarAccess.getSuperInvocationExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1427:1: ( rule__SuperInvocationExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1427:2: rule__SuperInvocationExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__SuperInvocationExpression__Group__0_in_ruleSuperInvocationExpression2990);

+            rule__SuperInvocationExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSuperInvocationExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSuperInvocationExpression"

+

+

+    // $ANTLR start "entryRuleInstanceCreationExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1439:1: entryRuleInstanceCreationExpression : ruleInstanceCreationExpression EOF ;

+    public final void entryRuleInstanceCreationExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1440:1: ( ruleInstanceCreationExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1441:1: ruleInstanceCreationExpression EOF

+            {

+             before(grammarAccess.getInstanceCreationExpressionRule()); 

+            pushFollow(FOLLOW_ruleInstanceCreationExpression_in_entryRuleInstanceCreationExpression3017);

+            ruleInstanceCreationExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getInstanceCreationExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleInstanceCreationExpression3024); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleInstanceCreationExpression"

+

+

+    // $ANTLR start "ruleInstanceCreationExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1448:1: ruleInstanceCreationExpression : ( ( rule__InstanceCreationExpression__Group__0 ) ) ;

+    public final void ruleInstanceCreationExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1452:2: ( ( ( rule__InstanceCreationExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1453:1: ( ( rule__InstanceCreationExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1453:1: ( ( rule__InstanceCreationExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1454:1: ( rule__InstanceCreationExpression__Group__0 )

+            {

+             before(grammarAccess.getInstanceCreationExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1455:1: ( rule__InstanceCreationExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1455:2: rule__InstanceCreationExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationExpression__Group__0_in_ruleInstanceCreationExpression3050);

+            rule__InstanceCreationExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInstanceCreationExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleInstanceCreationExpression"

+

+

+    // $ANTLR start "entryRuleInstanceCreationTuple"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1467:1: entryRuleInstanceCreationTuple : ruleInstanceCreationTuple EOF ;

+    public final void entryRuleInstanceCreationTuple() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1468:1: ( ruleInstanceCreationTuple EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1469:1: ruleInstanceCreationTuple EOF

+            {

+             before(grammarAccess.getInstanceCreationTupleRule()); 

+            pushFollow(FOLLOW_ruleInstanceCreationTuple_in_entryRuleInstanceCreationTuple3077);

+            ruleInstanceCreationTuple();

+

+            state._fsp--;

+

+             after(grammarAccess.getInstanceCreationTupleRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleInstanceCreationTuple3084); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleInstanceCreationTuple"

+

+

+    // $ANTLR start "ruleInstanceCreationTuple"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1476:1: ruleInstanceCreationTuple : ( ( rule__InstanceCreationTuple__Group__0 ) ) ;

+    public final void ruleInstanceCreationTuple() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1480:2: ( ( ( rule__InstanceCreationTuple__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1481:1: ( ( rule__InstanceCreationTuple__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1481:1: ( ( rule__InstanceCreationTuple__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1482:1: ( rule__InstanceCreationTuple__Group__0 )

+            {

+             before(grammarAccess.getInstanceCreationTupleAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1483:1: ( rule__InstanceCreationTuple__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1483:2: rule__InstanceCreationTuple__Group__0

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group__0_in_ruleInstanceCreationTuple3110);

+            rule__InstanceCreationTuple__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInstanceCreationTupleAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleInstanceCreationTuple"

+

+

+    // $ANTLR start "entryRuleInstanceCreationTupleElement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1495:1: entryRuleInstanceCreationTupleElement : ruleInstanceCreationTupleElement EOF ;

+    public final void entryRuleInstanceCreationTupleElement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1496:1: ( ruleInstanceCreationTupleElement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1497:1: ruleInstanceCreationTupleElement EOF

+            {

+             before(grammarAccess.getInstanceCreationTupleElementRule()); 

+            pushFollow(FOLLOW_ruleInstanceCreationTupleElement_in_entryRuleInstanceCreationTupleElement3137);

+            ruleInstanceCreationTupleElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getInstanceCreationTupleElementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleInstanceCreationTupleElement3144); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleInstanceCreationTupleElement"

+

+

+    // $ANTLR start "ruleInstanceCreationTupleElement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1504:1: ruleInstanceCreationTupleElement : ( ( rule__InstanceCreationTupleElement__Group__0 ) ) ;

+    public final void ruleInstanceCreationTupleElement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1508:2: ( ( ( rule__InstanceCreationTupleElement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1509:1: ( ( rule__InstanceCreationTupleElement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1509:1: ( ( rule__InstanceCreationTupleElement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1510:1: ( rule__InstanceCreationTupleElement__Group__0 )

+            {

+             before(grammarAccess.getInstanceCreationTupleElementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1511:1: ( rule__InstanceCreationTupleElement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1511:2: rule__InstanceCreationTupleElement__Group__0

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTupleElement__Group__0_in_ruleInstanceCreationTupleElement3170);

+            rule__InstanceCreationTupleElement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInstanceCreationTupleElementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleInstanceCreationTupleElement"

+

+

+    // $ANTLR start "entryRuleSequenceConstructionOrAccessCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1523:1: entryRuleSequenceConstructionOrAccessCompletion : ruleSequenceConstructionOrAccessCompletion EOF ;

+    public final void entryRuleSequenceConstructionOrAccessCompletion() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1524:1: ( ruleSequenceConstructionOrAccessCompletion EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1525:1: ruleSequenceConstructionOrAccessCompletion EOF

+            {

+             before(grammarAccess.getSequenceConstructionOrAccessCompletionRule()); 

+            pushFollow(FOLLOW_ruleSequenceConstructionOrAccessCompletion_in_entryRuleSequenceConstructionOrAccessCompletion3197);

+            ruleSequenceConstructionOrAccessCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceConstructionOrAccessCompletionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSequenceConstructionOrAccessCompletion3204); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSequenceConstructionOrAccessCompletion"

+

+

+    // $ANTLR start "ruleSequenceConstructionOrAccessCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1532:1: ruleSequenceConstructionOrAccessCompletion : ( ( rule__SequenceConstructionOrAccessCompletion__Alternatives ) ) ;

+    public final void ruleSequenceConstructionOrAccessCompletion() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1536:2: ( ( ( rule__SequenceConstructionOrAccessCompletion__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1537:1: ( ( rule__SequenceConstructionOrAccessCompletion__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1537:1: ( ( rule__SequenceConstructionOrAccessCompletion__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1538:1: ( rule__SequenceConstructionOrAccessCompletion__Alternatives )

+            {

+             before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1539:1: ( rule__SequenceConstructionOrAccessCompletion__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1539:2: rule__SequenceConstructionOrAccessCompletion__Alternatives

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionOrAccessCompletion__Alternatives_in_ruleSequenceConstructionOrAccessCompletion3230);

+            rule__SequenceConstructionOrAccessCompletion__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSequenceConstructionOrAccessCompletion"

+

+

+    // $ANTLR start "entryRuleAccessCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1551:1: entryRuleAccessCompletion : ruleAccessCompletion EOF ;

+    public final void entryRuleAccessCompletion() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1552:1: ( ruleAccessCompletion EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1553:1: ruleAccessCompletion EOF

+            {

+             before(grammarAccess.getAccessCompletionRule()); 

+            pushFollow(FOLLOW_ruleAccessCompletion_in_entryRuleAccessCompletion3257);

+            ruleAccessCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getAccessCompletionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleAccessCompletion3264); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleAccessCompletion"

+

+

+    // $ANTLR start "ruleAccessCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1560:1: ruleAccessCompletion : ( ( rule__AccessCompletion__Group__0 ) ) ;

+    public final void ruleAccessCompletion() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1564:2: ( ( ( rule__AccessCompletion__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1565:1: ( ( rule__AccessCompletion__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1565:1: ( ( rule__AccessCompletion__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1566:1: ( rule__AccessCompletion__Group__0 )

+            {

+             before(grammarAccess.getAccessCompletionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1567:1: ( rule__AccessCompletion__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1567:2: rule__AccessCompletion__Group__0

+            {

+            pushFollow(FOLLOW_rule__AccessCompletion__Group__0_in_ruleAccessCompletion3290);

+            rule__AccessCompletion__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAccessCompletionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleAccessCompletion"

+

+

+    // $ANTLR start "entryRulePartialSequenceConstructionCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1579:1: entryRulePartialSequenceConstructionCompletion : rulePartialSequenceConstructionCompletion EOF ;

+    public final void entryRulePartialSequenceConstructionCompletion() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1580:1: ( rulePartialSequenceConstructionCompletion EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1581:1: rulePartialSequenceConstructionCompletion EOF

+            {

+             before(grammarAccess.getPartialSequenceConstructionCompletionRule()); 

+            pushFollow(FOLLOW_rulePartialSequenceConstructionCompletion_in_entryRulePartialSequenceConstructionCompletion3317);

+            rulePartialSequenceConstructionCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getPartialSequenceConstructionCompletionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRulePartialSequenceConstructionCompletion3324); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRulePartialSequenceConstructionCompletion"

+

+

+    // $ANTLR start "rulePartialSequenceConstructionCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1588:1: rulePartialSequenceConstructionCompletion : ( ( rule__PartialSequenceConstructionCompletion__Group__0 ) ) ;

+    public final void rulePartialSequenceConstructionCompletion() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1592:2: ( ( ( rule__PartialSequenceConstructionCompletion__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1593:1: ( ( rule__PartialSequenceConstructionCompletion__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1593:1: ( ( rule__PartialSequenceConstructionCompletion__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1594:1: ( rule__PartialSequenceConstructionCompletion__Group__0 )

+            {

+             before(grammarAccess.getPartialSequenceConstructionCompletionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1595:1: ( rule__PartialSequenceConstructionCompletion__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1595:2: rule__PartialSequenceConstructionCompletion__Group__0

+            {

+            pushFollow(FOLLOW_rule__PartialSequenceConstructionCompletion__Group__0_in_rulePartialSequenceConstructionCompletion3350);

+            rule__PartialSequenceConstructionCompletion__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getPartialSequenceConstructionCompletionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rulePartialSequenceConstructionCompletion"

+

+

+    // $ANTLR start "entryRuleSequenceConstructionExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1607:1: entryRuleSequenceConstructionExpression : ruleSequenceConstructionExpression EOF ;

+    public final void entryRuleSequenceConstructionExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1608:1: ( ruleSequenceConstructionExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1609:1: ruleSequenceConstructionExpression EOF

+            {

+             before(grammarAccess.getSequenceConstructionExpressionRule()); 

+            pushFollow(FOLLOW_ruleSequenceConstructionExpression_in_entryRuleSequenceConstructionExpression3377);

+            ruleSequenceConstructionExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceConstructionExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSequenceConstructionExpression3384); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSequenceConstructionExpression"

+

+

+    // $ANTLR start "ruleSequenceConstructionExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1616:1: ruleSequenceConstructionExpression : ( ( rule__SequenceConstructionExpression__Group__0 ) ) ;

+    public final void ruleSequenceConstructionExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1620:2: ( ( ( rule__SequenceConstructionExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1621:1: ( ( rule__SequenceConstructionExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1621:1: ( ( rule__SequenceConstructionExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1622:1: ( rule__SequenceConstructionExpression__Group__0 )

+            {

+             before(grammarAccess.getSequenceConstructionExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1623:1: ( rule__SequenceConstructionExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1623:2: rule__SequenceConstructionExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group__0_in_ruleSequenceConstructionExpression3410);

+            rule__SequenceConstructionExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceConstructionExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSequenceConstructionExpression"

+

+

+    // $ANTLR start "entryRuleSequenceElement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1635:1: entryRuleSequenceElement : ruleSequenceElement EOF ;

+    public final void entryRuleSequenceElement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1636:1: ( ruleSequenceElement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1637:1: ruleSequenceElement EOF

+            {

+             before(grammarAccess.getSequenceElementRule()); 

+            pushFollow(FOLLOW_ruleSequenceElement_in_entryRuleSequenceElement3437);

+            ruleSequenceElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceElementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSequenceElement3444); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSequenceElement"

+

+

+    // $ANTLR start "ruleSequenceElement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1644:1: ruleSequenceElement : ( ( rule__SequenceElement__Alternatives ) ) ;

+    public final void ruleSequenceElement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1648:2: ( ( ( rule__SequenceElement__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1649:1: ( ( rule__SequenceElement__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1649:1: ( ( rule__SequenceElement__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1650:1: ( rule__SequenceElement__Alternatives )

+            {

+             before(grammarAccess.getSequenceElementAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1651:1: ( rule__SequenceElement__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1651:2: rule__SequenceElement__Alternatives

+            {

+            pushFollow(FOLLOW_rule__SequenceElement__Alternatives_in_ruleSequenceElement3470);

+            rule__SequenceElement__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceElementAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSequenceElement"

+

+

+    // $ANTLR start "entryRuleClassExtentExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1663:1: entryRuleClassExtentExpression : ruleClassExtentExpression EOF ;

+    public final void entryRuleClassExtentExpression() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1664:1: ( ruleClassExtentExpression EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1665:1: ruleClassExtentExpression EOF

+            {

+             before(grammarAccess.getClassExtentExpressionRule()); 

+            pushFollow(FOLLOW_ruleClassExtentExpression_in_entryRuleClassExtentExpression3497);

+            ruleClassExtentExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassExtentExpressionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleClassExtentExpression3504); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleClassExtentExpression"

+

+

+    // $ANTLR start "ruleClassExtentExpression"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1672:1: ruleClassExtentExpression : ( ( rule__ClassExtentExpression__Group__0 ) ) ;

+    public final void ruleClassExtentExpression() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1676:2: ( ( ( rule__ClassExtentExpression__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1677:1: ( ( rule__ClassExtentExpression__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1677:1: ( ( rule__ClassExtentExpression__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1678:1: ( rule__ClassExtentExpression__Group__0 )

+            {

+             before(grammarAccess.getClassExtentExpressionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1679:1: ( rule__ClassExtentExpression__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1679:2: rule__ClassExtentExpression__Group__0

+            {

+            pushFollow(FOLLOW_rule__ClassExtentExpression__Group__0_in_ruleClassExtentExpression3530);

+            rule__ClassExtentExpression__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassExtentExpressionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleClassExtentExpression"

+

+

+    // $ANTLR start "entryRuleBlock"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1691:1: entryRuleBlock : ruleBlock EOF ;

+    public final void entryRuleBlock() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1692:1: ( ruleBlock EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1693:1: ruleBlock EOF

+            {

+             before(grammarAccess.getBlockRule()); 

+            pushFollow(FOLLOW_ruleBlock_in_entryRuleBlock3557);

+            ruleBlock();

+

+            state._fsp--;

+

+             after(grammarAccess.getBlockRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleBlock3564); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleBlock"

+

+

+    // $ANTLR start "ruleBlock"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1700:1: ruleBlock : ( ( rule__Block__Group__0 ) ) ;

+    public final void ruleBlock() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1704:2: ( ( ( rule__Block__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1705:1: ( ( rule__Block__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1705:1: ( ( rule__Block__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1706:1: ( rule__Block__Group__0 )

+            {

+             before(grammarAccess.getBlockAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1707:1: ( rule__Block__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1707:2: rule__Block__Group__0

+            {

+            pushFollow(FOLLOW_rule__Block__Group__0_in_ruleBlock3590);

+            rule__Block__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getBlockAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleBlock"

+

+

+    // $ANTLR start "entryRuleStatementSequence"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1719:1: entryRuleStatementSequence : ruleStatementSequence EOF ;

+    public final void entryRuleStatementSequence() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1720:1: ( ruleStatementSequence EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1721:1: ruleStatementSequence EOF

+            {

+             before(grammarAccess.getStatementSequenceRule()); 

+            pushFollow(FOLLOW_ruleStatementSequence_in_entryRuleStatementSequence3617);

+            ruleStatementSequence();

+

+            state._fsp--;

+

+             after(grammarAccess.getStatementSequenceRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleStatementSequence3624); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleStatementSequence"

+

+

+    // $ANTLR start "ruleStatementSequence"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1728:1: ruleStatementSequence : ( ( ( rule__StatementSequence__StatementsAssignment ) ) ( ( rule__StatementSequence__StatementsAssignment )* ) ) ;

+    public final void ruleStatementSequence() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1732:2: ( ( ( ( rule__StatementSequence__StatementsAssignment ) ) ( ( rule__StatementSequence__StatementsAssignment )* ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1733:1: ( ( ( rule__StatementSequence__StatementsAssignment ) ) ( ( rule__StatementSequence__StatementsAssignment )* ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1733:1: ( ( ( rule__StatementSequence__StatementsAssignment ) ) ( ( rule__StatementSequence__StatementsAssignment )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1734:1: ( ( rule__StatementSequence__StatementsAssignment ) ) ( ( rule__StatementSequence__StatementsAssignment )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1734:1: ( ( rule__StatementSequence__StatementsAssignment ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1735:1: ( rule__StatementSequence__StatementsAssignment )

+            {

+             before(grammarAccess.getStatementSequenceAccess().getStatementsAssignment()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1736:1: ( rule__StatementSequence__StatementsAssignment )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1736:2: rule__StatementSequence__StatementsAssignment

+            {

+            pushFollow(FOLLOW_rule__StatementSequence__StatementsAssignment_in_ruleStatementSequence3652);

+            rule__StatementSequence__StatementsAssignment();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getStatementSequenceAccess().getStatementsAssignment()); 

+

+            }

+

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1739:1: ( ( rule__StatementSequence__StatementsAssignment )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1740:1: ( rule__StatementSequence__StatementsAssignment )*

+            {

+             before(grammarAccess.getStatementSequenceAccess().getStatementsAssignment()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1741:1: ( rule__StatementSequence__StatementsAssignment )*

+            loop2:

+            do {

+                int alt2=2;

+                int LA2_0 = input.LA(1);

+

+                if ( ((LA2_0>=RULE_ML_COMMENT && LA2_0<=RULE_SL_COMMENT)||LA2_0==RULE_ID||(LA2_0>=12 && LA2_0<=13)||(LA2_0>=84 && LA2_0<=87)||LA2_0==91||(LA2_0>=94 && LA2_0<=97)||LA2_0==100||(LA2_0>=103 && LA2_0<=105)||(LA2_0>=107 && LA2_0<=110)) ) {

+                    alt2=1;

+                }

+

+

+                switch (alt2) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1741:2: rule__StatementSequence__StatementsAssignment

+            	    {

+            	    pushFollow(FOLLOW_rule__StatementSequence__StatementsAssignment_in_ruleStatementSequence3664);

+            	    rule__StatementSequence__StatementsAssignment();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop2;

+                }

+            } while (true);

+

+             after(grammarAccess.getStatementSequenceAccess().getStatementsAssignment()); 

+

+            }

+

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleStatementSequence"

+

+

+    // $ANTLR start "entryRuleDocumentedStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1754:1: entryRuleDocumentedStatement : ruleDocumentedStatement EOF ;

+    public final void entryRuleDocumentedStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1755:1: ( ruleDocumentedStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1756:1: ruleDocumentedStatement EOF

+            {

+             before(grammarAccess.getDocumentedStatementRule()); 

+            pushFollow(FOLLOW_ruleDocumentedStatement_in_entryRuleDocumentedStatement3694);

+            ruleDocumentedStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getDocumentedStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleDocumentedStatement3701); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleDocumentedStatement"

+

+

+    // $ANTLR start "ruleDocumentedStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1763:1: ruleDocumentedStatement : ( ( rule__DocumentedStatement__Group__0 ) ) ;

+    public final void ruleDocumentedStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1767:2: ( ( ( rule__DocumentedStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1768:1: ( ( rule__DocumentedStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1768:1: ( ( rule__DocumentedStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1769:1: ( rule__DocumentedStatement__Group__0 )

+            {

+             before(grammarAccess.getDocumentedStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1770:1: ( rule__DocumentedStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1770:2: rule__DocumentedStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__DocumentedStatement__Group__0_in_ruleDocumentedStatement3727);

+            rule__DocumentedStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getDocumentedStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleDocumentedStatement"

+

+

+    // $ANTLR start "entryRuleInlineStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1782:1: entryRuleInlineStatement : ruleInlineStatement EOF ;

+    public final void entryRuleInlineStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1783:1: ( ruleInlineStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1784:1: ruleInlineStatement EOF

+            {

+             before(grammarAccess.getInlineStatementRule()); 

+            pushFollow(FOLLOW_ruleInlineStatement_in_entryRuleInlineStatement3754);

+            ruleInlineStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getInlineStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleInlineStatement3761); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleInlineStatement"

+

+

+    // $ANTLR start "ruleInlineStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1791:1: ruleInlineStatement : ( ( rule__InlineStatement__Group__0 ) ) ;

+    public final void ruleInlineStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1795:2: ( ( ( rule__InlineStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1796:1: ( ( rule__InlineStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1796:1: ( ( rule__InlineStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1797:1: ( rule__InlineStatement__Group__0 )

+            {

+             before(grammarAccess.getInlineStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1798:1: ( rule__InlineStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1798:2: rule__InlineStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__InlineStatement__Group__0_in_ruleInlineStatement3787);

+            rule__InlineStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInlineStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleInlineStatement"

+

+

+    // $ANTLR start "entryRuleAnnotatedStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1810:1: entryRuleAnnotatedStatement : ruleAnnotatedStatement EOF ;

+    public final void entryRuleAnnotatedStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1811:1: ( ruleAnnotatedStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1812:1: ruleAnnotatedStatement EOF

+            {

+             before(grammarAccess.getAnnotatedStatementRule()); 

+            pushFollow(FOLLOW_ruleAnnotatedStatement_in_entryRuleAnnotatedStatement3814);

+            ruleAnnotatedStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getAnnotatedStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleAnnotatedStatement3821); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleAnnotatedStatement"

+

+

+    // $ANTLR start "ruleAnnotatedStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1819:1: ruleAnnotatedStatement : ( ( rule__AnnotatedStatement__Group__0 ) ) ;

+    public final void ruleAnnotatedStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1823:2: ( ( ( rule__AnnotatedStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1824:1: ( ( rule__AnnotatedStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1824:1: ( ( rule__AnnotatedStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1825:1: ( rule__AnnotatedStatement__Group__0 )

+            {

+             before(grammarAccess.getAnnotatedStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1826:1: ( rule__AnnotatedStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1826:2: rule__AnnotatedStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__AnnotatedStatement__Group__0_in_ruleAnnotatedStatement3847);

+            rule__AnnotatedStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAnnotatedStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleAnnotatedStatement"

+

+

+    // $ANTLR start "entryRuleStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1838:1: entryRuleStatement : ruleStatement EOF ;

+    public final void entryRuleStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1839:1: ( ruleStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1840:1: ruleStatement EOF

+            {

+             before(grammarAccess.getStatementRule()); 

+            pushFollow(FOLLOW_ruleStatement_in_entryRuleStatement3874);

+            ruleStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleStatement3881); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleStatement"

+

+

+    // $ANTLR start "ruleStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1847:1: ruleStatement : ( ( rule__Statement__Alternatives ) ) ;

+    public final void ruleStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1851:2: ( ( ( rule__Statement__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1852:1: ( ( rule__Statement__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1852:1: ( ( rule__Statement__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1853:1: ( rule__Statement__Alternatives )

+            {

+             before(grammarAccess.getStatementAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1854:1: ( rule__Statement__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1854:2: rule__Statement__Alternatives

+            {

+            pushFollow(FOLLOW_rule__Statement__Alternatives_in_ruleStatement3907);

+            rule__Statement__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getStatementAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleStatement"

+

+

+    // $ANTLR start "entryRuleAnnotation"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1866:1: entryRuleAnnotation : ruleAnnotation EOF ;

+    public final void entryRuleAnnotation() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1867:1: ( ruleAnnotation EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1868:1: ruleAnnotation EOF

+            {

+             before(grammarAccess.getAnnotationRule()); 

+            pushFollow(FOLLOW_ruleAnnotation_in_entryRuleAnnotation3934);

+            ruleAnnotation();

+

+            state._fsp--;

+

+             after(grammarAccess.getAnnotationRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleAnnotation3941); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleAnnotation"

+

+

+    // $ANTLR start "ruleAnnotation"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1875:1: ruleAnnotation : ( ( rule__Annotation__Group__0 ) ) ;

+    public final void ruleAnnotation() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1879:2: ( ( ( rule__Annotation__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1880:1: ( ( rule__Annotation__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1880:1: ( ( rule__Annotation__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1881:1: ( rule__Annotation__Group__0 )

+            {

+             before(grammarAccess.getAnnotationAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1882:1: ( rule__Annotation__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1882:2: rule__Annotation__Group__0

+            {

+            pushFollow(FOLLOW_rule__Annotation__Group__0_in_ruleAnnotation3967);

+            rule__Annotation__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAnnotationAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleAnnotation"

+

+

+    // $ANTLR start "entryRuleBlockStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1894:1: entryRuleBlockStatement : ruleBlockStatement EOF ;

+    public final void entryRuleBlockStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1895:1: ( ruleBlockStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1896:1: ruleBlockStatement EOF

+            {

+             before(grammarAccess.getBlockStatementRule()); 

+            pushFollow(FOLLOW_ruleBlockStatement_in_entryRuleBlockStatement3994);

+            ruleBlockStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getBlockStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleBlockStatement4001); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleBlockStatement"

+

+

+    // $ANTLR start "ruleBlockStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1903:1: ruleBlockStatement : ( ( rule__BlockStatement__BlockAssignment ) ) ;

+    public final void ruleBlockStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1907:2: ( ( ( rule__BlockStatement__BlockAssignment ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1908:1: ( ( rule__BlockStatement__BlockAssignment ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1908:1: ( ( rule__BlockStatement__BlockAssignment ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1909:1: ( rule__BlockStatement__BlockAssignment )

+            {

+             before(grammarAccess.getBlockStatementAccess().getBlockAssignment()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1910:1: ( rule__BlockStatement__BlockAssignment )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1910:2: rule__BlockStatement__BlockAssignment

+            {

+            pushFollow(FOLLOW_rule__BlockStatement__BlockAssignment_in_ruleBlockStatement4027);

+            rule__BlockStatement__BlockAssignment();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getBlockStatementAccess().getBlockAssignment()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleBlockStatement"

+

+

+    // $ANTLR start "entryRuleEmptyStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1922:1: entryRuleEmptyStatement : ruleEmptyStatement EOF ;

+    public final void entryRuleEmptyStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1923:1: ( ruleEmptyStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1924:1: ruleEmptyStatement EOF

+            {

+             before(grammarAccess.getEmptyStatementRule()); 

+            pushFollow(FOLLOW_ruleEmptyStatement_in_entryRuleEmptyStatement4054);

+            ruleEmptyStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getEmptyStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleEmptyStatement4061); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleEmptyStatement"

+

+

+    // $ANTLR start "ruleEmptyStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1931:1: ruleEmptyStatement : ( ( rule__EmptyStatement__Group__0 ) ) ;

+    public final void ruleEmptyStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1935:2: ( ( ( rule__EmptyStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1936:1: ( ( rule__EmptyStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1936:1: ( ( rule__EmptyStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1937:1: ( rule__EmptyStatement__Group__0 )

+            {

+             before(grammarAccess.getEmptyStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1938:1: ( rule__EmptyStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1938:2: rule__EmptyStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__EmptyStatement__Group__0_in_ruleEmptyStatement4087);

+            rule__EmptyStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getEmptyStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleEmptyStatement"

+

+

+    // $ANTLR start "entryRuleLocalNameDeclarationStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1950:1: entryRuleLocalNameDeclarationStatement : ruleLocalNameDeclarationStatement EOF ;

+    public final void entryRuleLocalNameDeclarationStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1951:1: ( ruleLocalNameDeclarationStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1952:1: ruleLocalNameDeclarationStatement EOF

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementRule()); 

+            pushFollow(FOLLOW_ruleLocalNameDeclarationStatement_in_entryRuleLocalNameDeclarationStatement4114);

+            ruleLocalNameDeclarationStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getLocalNameDeclarationStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleLocalNameDeclarationStatement4121); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleLocalNameDeclarationStatement"

+

+

+    // $ANTLR start "ruleLocalNameDeclarationStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1959:1: ruleLocalNameDeclarationStatement : ( ( rule__LocalNameDeclarationStatement__Group__0 ) ) ;

+    public final void ruleLocalNameDeclarationStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1963:2: ( ( ( rule__LocalNameDeclarationStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1964:1: ( ( rule__LocalNameDeclarationStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1964:1: ( ( rule__LocalNameDeclarationStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1965:1: ( rule__LocalNameDeclarationStatement__Group__0 )

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1966:1: ( rule__LocalNameDeclarationStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1966:2: rule__LocalNameDeclarationStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__0_in_ruleLocalNameDeclarationStatement4147);

+            rule__LocalNameDeclarationStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleLocalNameDeclarationStatement"

+

+

+    // $ANTLR start "entryRuleIfStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1978:1: entryRuleIfStatement : ruleIfStatement EOF ;

+    public final void entryRuleIfStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1979:1: ( ruleIfStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1980:1: ruleIfStatement EOF

+            {

+             before(grammarAccess.getIfStatementRule()); 

+            pushFollow(FOLLOW_ruleIfStatement_in_entryRuleIfStatement4174);

+            ruleIfStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getIfStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleIfStatement4181); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleIfStatement"

+

+

+    // $ANTLR start "ruleIfStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1987:1: ruleIfStatement : ( ( rule__IfStatement__Group__0 ) ) ;

+    public final void ruleIfStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1991:2: ( ( ( rule__IfStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1992:1: ( ( rule__IfStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1992:1: ( ( rule__IfStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1993:1: ( rule__IfStatement__Group__0 )

+            {

+             before(grammarAccess.getIfStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1994:1: ( rule__IfStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:1994:2: rule__IfStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__IfStatement__Group__0_in_ruleIfStatement4207);

+            rule__IfStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getIfStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleIfStatement"

+

+

+    // $ANTLR start "entryRuleSequentialClauses"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2006:1: entryRuleSequentialClauses : ruleSequentialClauses EOF ;

+    public final void entryRuleSequentialClauses() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2007:1: ( ruleSequentialClauses EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2008:1: ruleSequentialClauses EOF

+            {

+             before(grammarAccess.getSequentialClausesRule()); 

+            pushFollow(FOLLOW_ruleSequentialClauses_in_entryRuleSequentialClauses4234);

+            ruleSequentialClauses();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequentialClausesRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSequentialClauses4241); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSequentialClauses"

+

+

+    // $ANTLR start "ruleSequentialClauses"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2015:1: ruleSequentialClauses : ( ( rule__SequentialClauses__Group__0 ) ) ;

+    public final void ruleSequentialClauses() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2019:2: ( ( ( rule__SequentialClauses__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2020:1: ( ( rule__SequentialClauses__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2020:1: ( ( rule__SequentialClauses__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2021:1: ( rule__SequentialClauses__Group__0 )

+            {

+             before(grammarAccess.getSequentialClausesAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2022:1: ( rule__SequentialClauses__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2022:2: rule__SequentialClauses__Group__0

+            {

+            pushFollow(FOLLOW_rule__SequentialClauses__Group__0_in_ruleSequentialClauses4267);

+            rule__SequentialClauses__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequentialClausesAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSequentialClauses"

+

+

+    // $ANTLR start "entryRuleConcurrentClauses"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2034:1: entryRuleConcurrentClauses : ruleConcurrentClauses EOF ;

+    public final void entryRuleConcurrentClauses() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2035:1: ( ruleConcurrentClauses EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2036:1: ruleConcurrentClauses EOF

+            {

+             before(grammarAccess.getConcurrentClausesRule()); 

+            pushFollow(FOLLOW_ruleConcurrentClauses_in_entryRuleConcurrentClauses4294);

+            ruleConcurrentClauses();

+

+            state._fsp--;

+

+             after(grammarAccess.getConcurrentClausesRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleConcurrentClauses4301); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleConcurrentClauses"

+

+

+    // $ANTLR start "ruleConcurrentClauses"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2043:1: ruleConcurrentClauses : ( ( rule__ConcurrentClauses__Group__0 ) ) ;

+    public final void ruleConcurrentClauses() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2047:2: ( ( ( rule__ConcurrentClauses__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2048:1: ( ( rule__ConcurrentClauses__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2048:1: ( ( rule__ConcurrentClauses__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2049:1: ( rule__ConcurrentClauses__Group__0 )

+            {

+             before(grammarAccess.getConcurrentClausesAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2050:1: ( rule__ConcurrentClauses__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2050:2: rule__ConcurrentClauses__Group__0

+            {

+            pushFollow(FOLLOW_rule__ConcurrentClauses__Group__0_in_ruleConcurrentClauses4327);

+            rule__ConcurrentClauses__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getConcurrentClausesAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleConcurrentClauses"

+

+

+    // $ANTLR start "entryRuleNonFinalClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2062:1: entryRuleNonFinalClause : ruleNonFinalClause EOF ;

+    public final void entryRuleNonFinalClause() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2063:1: ( ruleNonFinalClause EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2064:1: ruleNonFinalClause EOF

+            {

+             before(grammarAccess.getNonFinalClauseRule()); 

+            pushFollow(FOLLOW_ruleNonFinalClause_in_entryRuleNonFinalClause4354);

+            ruleNonFinalClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getNonFinalClauseRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleNonFinalClause4361); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleNonFinalClause"

+

+

+    // $ANTLR start "ruleNonFinalClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2071:1: ruleNonFinalClause : ( ( rule__NonFinalClause__Group__0 ) ) ;

+    public final void ruleNonFinalClause() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2075:2: ( ( ( rule__NonFinalClause__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2076:1: ( ( rule__NonFinalClause__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2076:1: ( ( rule__NonFinalClause__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2077:1: ( rule__NonFinalClause__Group__0 )

+            {

+             before(grammarAccess.getNonFinalClauseAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2078:1: ( rule__NonFinalClause__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2078:2: rule__NonFinalClause__Group__0

+            {

+            pushFollow(FOLLOW_rule__NonFinalClause__Group__0_in_ruleNonFinalClause4387);

+            rule__NonFinalClause__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNonFinalClauseAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleNonFinalClause"

+

+

+    // $ANTLR start "entryRuleFinalClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2090:1: entryRuleFinalClause : ruleFinalClause EOF ;

+    public final void entryRuleFinalClause() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2091:1: ( ruleFinalClause EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2092:1: ruleFinalClause EOF

+            {

+             before(grammarAccess.getFinalClauseRule()); 

+            pushFollow(FOLLOW_ruleFinalClause_in_entryRuleFinalClause4414);

+            ruleFinalClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getFinalClauseRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleFinalClause4421); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleFinalClause"

+

+

+    // $ANTLR start "ruleFinalClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2099:1: ruleFinalClause : ( ( rule__FinalClause__Group__0 ) ) ;

+    public final void ruleFinalClause() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2103:2: ( ( ( rule__FinalClause__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2104:1: ( ( rule__FinalClause__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2104:1: ( ( rule__FinalClause__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2105:1: ( rule__FinalClause__Group__0 )

+            {

+             before(grammarAccess.getFinalClauseAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2106:1: ( rule__FinalClause__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2106:2: rule__FinalClause__Group__0

+            {

+            pushFollow(FOLLOW_rule__FinalClause__Group__0_in_ruleFinalClause4447);

+            rule__FinalClause__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getFinalClauseAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleFinalClause"

+

+

+    // $ANTLR start "entryRuleSwitchStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2118:1: entryRuleSwitchStatement : ruleSwitchStatement EOF ;

+    public final void entryRuleSwitchStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2119:1: ( ruleSwitchStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2120:1: ruleSwitchStatement EOF

+            {

+             before(grammarAccess.getSwitchStatementRule()); 

+            pushFollow(FOLLOW_ruleSwitchStatement_in_entryRuleSwitchStatement4474);

+            ruleSwitchStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getSwitchStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSwitchStatement4481); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSwitchStatement"

+

+

+    // $ANTLR start "ruleSwitchStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2127:1: ruleSwitchStatement : ( ( rule__SwitchStatement__Group__0 ) ) ;

+    public final void ruleSwitchStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2131:2: ( ( ( rule__SwitchStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2132:1: ( ( rule__SwitchStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2132:1: ( ( rule__SwitchStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2133:1: ( rule__SwitchStatement__Group__0 )

+            {

+             before(grammarAccess.getSwitchStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2134:1: ( rule__SwitchStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2134:2: rule__SwitchStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__0_in_ruleSwitchStatement4507);

+            rule__SwitchStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSwitchStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSwitchStatement"

+

+

+    // $ANTLR start "entryRuleSwitchClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2146:1: entryRuleSwitchClause : ruleSwitchClause EOF ;

+    public final void entryRuleSwitchClause() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2147:1: ( ruleSwitchClause EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2148:1: ruleSwitchClause EOF

+            {

+             before(grammarAccess.getSwitchClauseRule()); 

+            pushFollow(FOLLOW_ruleSwitchClause_in_entryRuleSwitchClause4534);

+            ruleSwitchClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getSwitchClauseRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSwitchClause4541); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSwitchClause"

+

+

+    // $ANTLR start "ruleSwitchClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2155:1: ruleSwitchClause : ( ( rule__SwitchClause__Group__0 ) ) ;

+    public final void ruleSwitchClause() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2159:2: ( ( ( rule__SwitchClause__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2160:1: ( ( rule__SwitchClause__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2160:1: ( ( rule__SwitchClause__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2161:1: ( rule__SwitchClause__Group__0 )

+            {

+             before(grammarAccess.getSwitchClauseAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2162:1: ( rule__SwitchClause__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2162:2: rule__SwitchClause__Group__0

+            {

+            pushFollow(FOLLOW_rule__SwitchClause__Group__0_in_ruleSwitchClause4567);

+            rule__SwitchClause__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSwitchClauseAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSwitchClause"

+

+

+    // $ANTLR start "entryRuleSwitchCase"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2174:1: entryRuleSwitchCase : ruleSwitchCase EOF ;

+    public final void entryRuleSwitchCase() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2175:1: ( ruleSwitchCase EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2176:1: ruleSwitchCase EOF

+            {

+             before(grammarAccess.getSwitchCaseRule()); 

+            pushFollow(FOLLOW_ruleSwitchCase_in_entryRuleSwitchCase4594);

+            ruleSwitchCase();

+

+            state._fsp--;

+

+             after(grammarAccess.getSwitchCaseRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSwitchCase4601); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSwitchCase"

+

+

+    // $ANTLR start "ruleSwitchCase"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2183:1: ruleSwitchCase : ( ( rule__SwitchCase__Group__0 ) ) ;

+    public final void ruleSwitchCase() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2187:2: ( ( ( rule__SwitchCase__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2188:1: ( ( rule__SwitchCase__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2188:1: ( ( rule__SwitchCase__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2189:1: ( rule__SwitchCase__Group__0 )

+            {

+             before(grammarAccess.getSwitchCaseAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2190:1: ( rule__SwitchCase__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2190:2: rule__SwitchCase__Group__0

+            {

+            pushFollow(FOLLOW_rule__SwitchCase__Group__0_in_ruleSwitchCase4627);

+            rule__SwitchCase__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSwitchCaseAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSwitchCase"

+

+

+    // $ANTLR start "entryRuleSwitchDefaultClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2202:1: entryRuleSwitchDefaultClause : ruleSwitchDefaultClause EOF ;

+    public final void entryRuleSwitchDefaultClause() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2203:1: ( ruleSwitchDefaultClause EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2204:1: ruleSwitchDefaultClause EOF

+            {

+             before(grammarAccess.getSwitchDefaultClauseRule()); 

+            pushFollow(FOLLOW_ruleSwitchDefaultClause_in_entryRuleSwitchDefaultClause4654);

+            ruleSwitchDefaultClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getSwitchDefaultClauseRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSwitchDefaultClause4661); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSwitchDefaultClause"

+

+

+    // $ANTLR start "ruleSwitchDefaultClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2211:1: ruleSwitchDefaultClause : ( ( rule__SwitchDefaultClause__Group__0 ) ) ;

+    public final void ruleSwitchDefaultClause() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2215:2: ( ( ( rule__SwitchDefaultClause__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2216:1: ( ( rule__SwitchDefaultClause__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2216:1: ( ( rule__SwitchDefaultClause__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2217:1: ( rule__SwitchDefaultClause__Group__0 )

+            {

+             before(grammarAccess.getSwitchDefaultClauseAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2218:1: ( rule__SwitchDefaultClause__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2218:2: rule__SwitchDefaultClause__Group__0

+            {

+            pushFollow(FOLLOW_rule__SwitchDefaultClause__Group__0_in_ruleSwitchDefaultClause4687);

+            rule__SwitchDefaultClause__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSwitchDefaultClauseAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSwitchDefaultClause"

+

+

+    // $ANTLR start "entryRuleNonEmptyStatementSequence"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2230:1: entryRuleNonEmptyStatementSequence : ruleNonEmptyStatementSequence EOF ;

+    public final void entryRuleNonEmptyStatementSequence() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2231:1: ( ruleNonEmptyStatementSequence EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2232:1: ruleNonEmptyStatementSequence EOF

+            {

+             before(grammarAccess.getNonEmptyStatementSequenceRule()); 

+            pushFollow(FOLLOW_ruleNonEmptyStatementSequence_in_entryRuleNonEmptyStatementSequence4714);

+            ruleNonEmptyStatementSequence();

+

+            state._fsp--;

+

+             after(grammarAccess.getNonEmptyStatementSequenceRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleNonEmptyStatementSequence4721); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleNonEmptyStatementSequence"

+

+

+    // $ANTLR start "ruleNonEmptyStatementSequence"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2239:1: ruleNonEmptyStatementSequence : ( ( ( rule__NonEmptyStatementSequence__StatementAssignment ) ) ( ( rule__NonEmptyStatementSequence__StatementAssignment )* ) ) ;

+    public final void ruleNonEmptyStatementSequence() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2243:2: ( ( ( ( rule__NonEmptyStatementSequence__StatementAssignment ) ) ( ( rule__NonEmptyStatementSequence__StatementAssignment )* ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2244:1: ( ( ( rule__NonEmptyStatementSequence__StatementAssignment ) ) ( ( rule__NonEmptyStatementSequence__StatementAssignment )* ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2244:1: ( ( ( rule__NonEmptyStatementSequence__StatementAssignment ) ) ( ( rule__NonEmptyStatementSequence__StatementAssignment )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2245:1: ( ( rule__NonEmptyStatementSequence__StatementAssignment ) ) ( ( rule__NonEmptyStatementSequence__StatementAssignment )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2245:1: ( ( rule__NonEmptyStatementSequence__StatementAssignment ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2246:1: ( rule__NonEmptyStatementSequence__StatementAssignment )

+            {

+             before(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2247:1: ( rule__NonEmptyStatementSequence__StatementAssignment )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2247:2: rule__NonEmptyStatementSequence__StatementAssignment

+            {

+            pushFollow(FOLLOW_rule__NonEmptyStatementSequence__StatementAssignment_in_ruleNonEmptyStatementSequence4749);

+            rule__NonEmptyStatementSequence__StatementAssignment();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment()); 

+

+            }

+

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2250:1: ( ( rule__NonEmptyStatementSequence__StatementAssignment )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2251:1: ( rule__NonEmptyStatementSequence__StatementAssignment )*

+            {

+             before(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2252:1: ( rule__NonEmptyStatementSequence__StatementAssignment )*

+            loop3:

+            do {

+                int alt3=2;

+                int LA3_0 = input.LA(1);

+

+                if ( ((LA3_0>=RULE_ML_COMMENT && LA3_0<=RULE_SL_COMMENT)||LA3_0==RULE_ID||(LA3_0>=12 && LA3_0<=13)||(LA3_0>=84 && LA3_0<=87)||LA3_0==91||(LA3_0>=94 && LA3_0<=97)||LA3_0==100||(LA3_0>=103 && LA3_0<=105)||(LA3_0>=107 && LA3_0<=110)) ) {

+                    alt3=1;

+                }

+

+

+                switch (alt3) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2252:2: rule__NonEmptyStatementSequence__StatementAssignment

+            	    {

+            	    pushFollow(FOLLOW_rule__NonEmptyStatementSequence__StatementAssignment_in_ruleNonEmptyStatementSequence4761);

+            	    rule__NonEmptyStatementSequence__StatementAssignment();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop3;

+                }

+            } while (true);

+

+             after(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementAssignment()); 

+

+            }

+

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleNonEmptyStatementSequence"

+

+

+    // $ANTLR start "entryRuleWhileStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2265:1: entryRuleWhileStatement : ruleWhileStatement EOF ;

+    public final void entryRuleWhileStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2266:1: ( ruleWhileStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2267:1: ruleWhileStatement EOF

+            {

+             before(grammarAccess.getWhileStatementRule()); 

+            pushFollow(FOLLOW_ruleWhileStatement_in_entryRuleWhileStatement4791);

+            ruleWhileStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getWhileStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleWhileStatement4798); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleWhileStatement"

+

+

+    // $ANTLR start "ruleWhileStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2274:1: ruleWhileStatement : ( ( rule__WhileStatement__Group__0 ) ) ;

+    public final void ruleWhileStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2278:2: ( ( ( rule__WhileStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2279:1: ( ( rule__WhileStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2279:1: ( ( rule__WhileStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2280:1: ( rule__WhileStatement__Group__0 )

+            {

+             before(grammarAccess.getWhileStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2281:1: ( rule__WhileStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2281:2: rule__WhileStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__WhileStatement__Group__0_in_ruleWhileStatement4824);

+            rule__WhileStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getWhileStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleWhileStatement"

+

+

+    // $ANTLR start "entryRuleDoStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2293:1: entryRuleDoStatement : ruleDoStatement EOF ;

+    public final void entryRuleDoStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2294:1: ( ruleDoStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2295:1: ruleDoStatement EOF

+            {

+             before(grammarAccess.getDoStatementRule()); 

+            pushFollow(FOLLOW_ruleDoStatement_in_entryRuleDoStatement4851);

+            ruleDoStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getDoStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleDoStatement4858); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleDoStatement"

+

+

+    // $ANTLR start "ruleDoStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2302:1: ruleDoStatement : ( ( rule__DoStatement__Group__0 ) ) ;

+    public final void ruleDoStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2306:2: ( ( ( rule__DoStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2307:1: ( ( rule__DoStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2307:1: ( ( rule__DoStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2308:1: ( rule__DoStatement__Group__0 )

+            {

+             before(grammarAccess.getDoStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2309:1: ( rule__DoStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2309:2: rule__DoStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__DoStatement__Group__0_in_ruleDoStatement4884);

+            rule__DoStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getDoStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleDoStatement"

+

+

+    // $ANTLR start "entryRuleForStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2321:1: entryRuleForStatement : ruleForStatement EOF ;

+    public final void entryRuleForStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2322:1: ( ruleForStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2323:1: ruleForStatement EOF

+            {

+             before(grammarAccess.getForStatementRule()); 

+            pushFollow(FOLLOW_ruleForStatement_in_entryRuleForStatement4911);

+            ruleForStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getForStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleForStatement4918); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleForStatement"

+

+

+    // $ANTLR start "ruleForStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2330:1: ruleForStatement : ( ( rule__ForStatement__Group__0 ) ) ;

+    public final void ruleForStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2334:2: ( ( ( rule__ForStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2335:1: ( ( rule__ForStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2335:1: ( ( rule__ForStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2336:1: ( rule__ForStatement__Group__0 )

+            {

+             before(grammarAccess.getForStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2337:1: ( rule__ForStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2337:2: rule__ForStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__ForStatement__Group__0_in_ruleForStatement4944);

+            rule__ForStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getForStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleForStatement"

+

+

+    // $ANTLR start "entryRuleForControl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2349:1: entryRuleForControl : ruleForControl EOF ;

+    public final void entryRuleForControl() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2350:1: ( ruleForControl EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2351:1: ruleForControl EOF

+            {

+             before(grammarAccess.getForControlRule()); 

+            pushFollow(FOLLOW_ruleForControl_in_entryRuleForControl4971);

+            ruleForControl();

+

+            state._fsp--;

+

+             after(grammarAccess.getForControlRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleForControl4978); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleForControl"

+

+

+    // $ANTLR start "ruleForControl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2358:1: ruleForControl : ( ( rule__ForControl__Group__0 ) ) ;

+    public final void ruleForControl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2362:2: ( ( ( rule__ForControl__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2363:1: ( ( rule__ForControl__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2363:1: ( ( rule__ForControl__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2364:1: ( rule__ForControl__Group__0 )

+            {

+             before(grammarAccess.getForControlAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2365:1: ( rule__ForControl__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2365:2: rule__ForControl__Group__0

+            {

+            pushFollow(FOLLOW_rule__ForControl__Group__0_in_ruleForControl5004);

+            rule__ForControl__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getForControlAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleForControl"

+

+

+    // $ANTLR start "entryRuleLoopVariableDefinition"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2377:1: entryRuleLoopVariableDefinition : ruleLoopVariableDefinition EOF ;

+    public final void entryRuleLoopVariableDefinition() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2378:1: ( ruleLoopVariableDefinition EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2379:1: ruleLoopVariableDefinition EOF

+            {

+             before(grammarAccess.getLoopVariableDefinitionRule()); 

+            pushFollow(FOLLOW_ruleLoopVariableDefinition_in_entryRuleLoopVariableDefinition5031);

+            ruleLoopVariableDefinition();

+

+            state._fsp--;

+

+             after(grammarAccess.getLoopVariableDefinitionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleLoopVariableDefinition5038); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleLoopVariableDefinition"

+

+

+    // $ANTLR start "ruleLoopVariableDefinition"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2386:1: ruleLoopVariableDefinition : ( ( rule__LoopVariableDefinition__Alternatives ) ) ;

+    public final void ruleLoopVariableDefinition() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2390:2: ( ( ( rule__LoopVariableDefinition__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2391:1: ( ( rule__LoopVariableDefinition__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2391:1: ( ( rule__LoopVariableDefinition__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2392:1: ( rule__LoopVariableDefinition__Alternatives )

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2393:1: ( rule__LoopVariableDefinition__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2393:2: rule__LoopVariableDefinition__Alternatives

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Alternatives_in_ruleLoopVariableDefinition5064);

+            rule__LoopVariableDefinition__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLoopVariableDefinitionAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleLoopVariableDefinition"

+

+

+    // $ANTLR start "entryRuleBreakStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2405:1: entryRuleBreakStatement : ruleBreakStatement EOF ;

+    public final void entryRuleBreakStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2406:1: ( ruleBreakStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2407:1: ruleBreakStatement EOF

+            {

+             before(grammarAccess.getBreakStatementRule()); 

+            pushFollow(FOLLOW_ruleBreakStatement_in_entryRuleBreakStatement5091);

+            ruleBreakStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getBreakStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleBreakStatement5098); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleBreakStatement"

+

+

+    // $ANTLR start "ruleBreakStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2414:1: ruleBreakStatement : ( ( rule__BreakStatement__Group__0 ) ) ;

+    public final void ruleBreakStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2418:2: ( ( ( rule__BreakStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2419:1: ( ( rule__BreakStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2419:1: ( ( rule__BreakStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2420:1: ( rule__BreakStatement__Group__0 )

+            {

+             before(grammarAccess.getBreakStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2421:1: ( rule__BreakStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2421:2: rule__BreakStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__BreakStatement__Group__0_in_ruleBreakStatement5124);

+            rule__BreakStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getBreakStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleBreakStatement"

+

+

+    // $ANTLR start "entryRuleReturnStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2433:1: entryRuleReturnStatement : ruleReturnStatement EOF ;

+    public final void entryRuleReturnStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2434:1: ( ruleReturnStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2435:1: ruleReturnStatement EOF

+            {

+             before(grammarAccess.getReturnStatementRule()); 

+            pushFollow(FOLLOW_ruleReturnStatement_in_entryRuleReturnStatement5151);

+            ruleReturnStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getReturnStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleReturnStatement5158); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleReturnStatement"

+

+

+    // $ANTLR start "ruleReturnStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2442:1: ruleReturnStatement : ( ( rule__ReturnStatement__Group__0 ) ) ;

+    public final void ruleReturnStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2446:2: ( ( ( rule__ReturnStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2447:1: ( ( rule__ReturnStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2447:1: ( ( rule__ReturnStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2448:1: ( rule__ReturnStatement__Group__0 )

+            {

+             before(grammarAccess.getReturnStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2449:1: ( rule__ReturnStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2449:2: rule__ReturnStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__ReturnStatement__Group__0_in_ruleReturnStatement5184);

+            rule__ReturnStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getReturnStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleReturnStatement"

+

+

+    // $ANTLR start "entryRuleAcceptStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2461:1: entryRuleAcceptStatement : ruleAcceptStatement EOF ;

+    public final void entryRuleAcceptStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2462:1: ( ruleAcceptStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2463:1: ruleAcceptStatement EOF

+            {

+             before(grammarAccess.getAcceptStatementRule()); 

+            pushFollow(FOLLOW_ruleAcceptStatement_in_entryRuleAcceptStatement5211);

+            ruleAcceptStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getAcceptStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleAcceptStatement5218); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleAcceptStatement"

+

+

+    // $ANTLR start "ruleAcceptStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2470:1: ruleAcceptStatement : ( ( rule__AcceptStatement__Group__0 ) ) ;

+    public final void ruleAcceptStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2474:2: ( ( ( rule__AcceptStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2475:1: ( ( rule__AcceptStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2475:1: ( ( rule__AcceptStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2476:1: ( rule__AcceptStatement__Group__0 )

+            {

+             before(grammarAccess.getAcceptStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2477:1: ( rule__AcceptStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2477:2: rule__AcceptStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__AcceptStatement__Group__0_in_ruleAcceptStatement5244);

+            rule__AcceptStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAcceptStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleAcceptStatement"

+

+

+    // $ANTLR start "entryRuleSimpleAcceptStatementCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2489:1: entryRuleSimpleAcceptStatementCompletion : ruleSimpleAcceptStatementCompletion EOF ;

+    public final void entryRuleSimpleAcceptStatementCompletion() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2490:1: ( ruleSimpleAcceptStatementCompletion EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2491:1: ruleSimpleAcceptStatementCompletion EOF

+            {

+             before(grammarAccess.getSimpleAcceptStatementCompletionRule()); 

+            pushFollow(FOLLOW_ruleSimpleAcceptStatementCompletion_in_entryRuleSimpleAcceptStatementCompletion5271);

+            ruleSimpleAcceptStatementCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getSimpleAcceptStatementCompletionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSimpleAcceptStatementCompletion5278); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSimpleAcceptStatementCompletion"

+

+

+    // $ANTLR start "ruleSimpleAcceptStatementCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2498:1: ruleSimpleAcceptStatementCompletion : ( ( rule__SimpleAcceptStatementCompletion__Group__0 ) ) ;

+    public final void ruleSimpleAcceptStatementCompletion() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2502:2: ( ( ( rule__SimpleAcceptStatementCompletion__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2503:1: ( ( rule__SimpleAcceptStatementCompletion__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2503:1: ( ( rule__SimpleAcceptStatementCompletion__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2504:1: ( rule__SimpleAcceptStatementCompletion__Group__0 )

+            {

+             before(grammarAccess.getSimpleAcceptStatementCompletionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2505:1: ( rule__SimpleAcceptStatementCompletion__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2505:2: rule__SimpleAcceptStatementCompletion__Group__0

+            {

+            pushFollow(FOLLOW_rule__SimpleAcceptStatementCompletion__Group__0_in_ruleSimpleAcceptStatementCompletion5304);

+            rule__SimpleAcceptStatementCompletion__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSimpleAcceptStatementCompletionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSimpleAcceptStatementCompletion"

+

+

+    // $ANTLR start "entryRuleCompoundAcceptStatementCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2517:1: entryRuleCompoundAcceptStatementCompletion : ruleCompoundAcceptStatementCompletion EOF ;

+    public final void entryRuleCompoundAcceptStatementCompletion() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2518:1: ( ruleCompoundAcceptStatementCompletion EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2519:1: ruleCompoundAcceptStatementCompletion EOF

+            {

+             before(grammarAccess.getCompoundAcceptStatementCompletionRule()); 

+            pushFollow(FOLLOW_ruleCompoundAcceptStatementCompletion_in_entryRuleCompoundAcceptStatementCompletion5331);

+            ruleCompoundAcceptStatementCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getCompoundAcceptStatementCompletionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleCompoundAcceptStatementCompletion5338); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleCompoundAcceptStatementCompletion"

+

+

+    // $ANTLR start "ruleCompoundAcceptStatementCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2526:1: ruleCompoundAcceptStatementCompletion : ( ( rule__CompoundAcceptStatementCompletion__Group__0 ) ) ;

+    public final void ruleCompoundAcceptStatementCompletion() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2530:2: ( ( ( rule__CompoundAcceptStatementCompletion__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2531:1: ( ( rule__CompoundAcceptStatementCompletion__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2531:1: ( ( rule__CompoundAcceptStatementCompletion__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2532:1: ( rule__CompoundAcceptStatementCompletion__Group__0 )

+            {

+             before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2533:1: ( rule__CompoundAcceptStatementCompletion__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2533:2: rule__CompoundAcceptStatementCompletion__Group__0

+            {

+            pushFollow(FOLLOW_rule__CompoundAcceptStatementCompletion__Group__0_in_ruleCompoundAcceptStatementCompletion5364);

+            rule__CompoundAcceptStatementCompletion__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleCompoundAcceptStatementCompletion"

+

+

+    // $ANTLR start "entryRuleAcceptBlock"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2545:1: entryRuleAcceptBlock : ruleAcceptBlock EOF ;

+    public final void entryRuleAcceptBlock() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2546:1: ( ruleAcceptBlock EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2547:1: ruleAcceptBlock EOF

+            {

+             before(grammarAccess.getAcceptBlockRule()); 

+            pushFollow(FOLLOW_ruleAcceptBlock_in_entryRuleAcceptBlock5391);

+            ruleAcceptBlock();

+

+            state._fsp--;

+

+             after(grammarAccess.getAcceptBlockRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleAcceptBlock5398); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleAcceptBlock"

+

+

+    // $ANTLR start "ruleAcceptBlock"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2554:1: ruleAcceptBlock : ( ( rule__AcceptBlock__Group__0 ) ) ;

+    public final void ruleAcceptBlock() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2558:2: ( ( ( rule__AcceptBlock__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2559:1: ( ( rule__AcceptBlock__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2559:1: ( ( rule__AcceptBlock__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2560:1: ( rule__AcceptBlock__Group__0 )

+            {

+             before(grammarAccess.getAcceptBlockAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2561:1: ( rule__AcceptBlock__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2561:2: rule__AcceptBlock__Group__0

+            {

+            pushFollow(FOLLOW_rule__AcceptBlock__Group__0_in_ruleAcceptBlock5424);

+            rule__AcceptBlock__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAcceptBlockAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleAcceptBlock"

+

+

+    // $ANTLR start "entryRuleAcceptClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2573:1: entryRuleAcceptClause : ruleAcceptClause EOF ;

+    public final void entryRuleAcceptClause() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2574:1: ( ruleAcceptClause EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2575:1: ruleAcceptClause EOF

+            {

+             before(grammarAccess.getAcceptClauseRule()); 

+            pushFollow(FOLLOW_ruleAcceptClause_in_entryRuleAcceptClause5451);

+            ruleAcceptClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getAcceptClauseRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleAcceptClause5458); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleAcceptClause"

+

+

+    // $ANTLR start "ruleAcceptClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2582:1: ruleAcceptClause : ( ( rule__AcceptClause__Group__0 ) ) ;

+    public final void ruleAcceptClause() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2586:2: ( ( ( rule__AcceptClause__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2587:1: ( ( rule__AcceptClause__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2587:1: ( ( rule__AcceptClause__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2588:1: ( rule__AcceptClause__Group__0 )

+            {

+             before(grammarAccess.getAcceptClauseAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2589:1: ( rule__AcceptClause__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2589:2: rule__AcceptClause__Group__0

+            {

+            pushFollow(FOLLOW_rule__AcceptClause__Group__0_in_ruleAcceptClause5484);

+            rule__AcceptClause__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAcceptClauseAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleAcceptClause"

+

+

+    // $ANTLR start "entryRuleClassifyStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2601:1: entryRuleClassifyStatement : ruleClassifyStatement EOF ;

+    public final void entryRuleClassifyStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2602:1: ( ruleClassifyStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2603:1: ruleClassifyStatement EOF

+            {

+             before(grammarAccess.getClassifyStatementRule()); 

+            pushFollow(FOLLOW_ruleClassifyStatement_in_entryRuleClassifyStatement5511);

+            ruleClassifyStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassifyStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleClassifyStatement5518); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleClassifyStatement"

+

+

+    // $ANTLR start "ruleClassifyStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2610:1: ruleClassifyStatement : ( ( rule__ClassifyStatement__Group__0 ) ) ;

+    public final void ruleClassifyStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2614:2: ( ( ( rule__ClassifyStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2615:1: ( ( rule__ClassifyStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2615:1: ( ( rule__ClassifyStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2616:1: ( rule__ClassifyStatement__Group__0 )

+            {

+             before(grammarAccess.getClassifyStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2617:1: ( rule__ClassifyStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2617:2: rule__ClassifyStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__ClassifyStatement__Group__0_in_ruleClassifyStatement5544);

+            rule__ClassifyStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassifyStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleClassifyStatement"

+

+

+    // $ANTLR start "entryRuleClassificationClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2629:1: entryRuleClassificationClause : ruleClassificationClause EOF ;

+    public final void entryRuleClassificationClause() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2630:1: ( ruleClassificationClause EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2631:1: ruleClassificationClause EOF

+            {

+             before(grammarAccess.getClassificationClauseRule()); 

+            pushFollow(FOLLOW_ruleClassificationClause_in_entryRuleClassificationClause5571);

+            ruleClassificationClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassificationClauseRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleClassificationClause5578); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleClassificationClause"

+

+

+    // $ANTLR start "ruleClassificationClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2638:1: ruleClassificationClause : ( ( rule__ClassificationClause__Alternatives ) ) ;

+    public final void ruleClassificationClause() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2642:2: ( ( ( rule__ClassificationClause__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2643:1: ( ( rule__ClassificationClause__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2643:1: ( ( rule__ClassificationClause__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2644:1: ( rule__ClassificationClause__Alternatives )

+            {

+             before(grammarAccess.getClassificationClauseAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2645:1: ( rule__ClassificationClause__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2645:2: rule__ClassificationClause__Alternatives

+            {

+            pushFollow(FOLLOW_rule__ClassificationClause__Alternatives_in_ruleClassificationClause5604);

+            rule__ClassificationClause__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassificationClauseAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleClassificationClause"

+

+

+    // $ANTLR start "entryRuleClassificationFromClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2657:1: entryRuleClassificationFromClause : ruleClassificationFromClause EOF ;

+    public final void entryRuleClassificationFromClause() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2658:1: ( ruleClassificationFromClause EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2659:1: ruleClassificationFromClause EOF

+            {

+             before(grammarAccess.getClassificationFromClauseRule()); 

+            pushFollow(FOLLOW_ruleClassificationFromClause_in_entryRuleClassificationFromClause5631);

+            ruleClassificationFromClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassificationFromClauseRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleClassificationFromClause5638); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleClassificationFromClause"

+

+

+    // $ANTLR start "ruleClassificationFromClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2666:1: ruleClassificationFromClause : ( ( rule__ClassificationFromClause__Group__0 ) ) ;

+    public final void ruleClassificationFromClause() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2670:2: ( ( ( rule__ClassificationFromClause__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2671:1: ( ( rule__ClassificationFromClause__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2671:1: ( ( rule__ClassificationFromClause__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2672:1: ( rule__ClassificationFromClause__Group__0 )

+            {

+             before(grammarAccess.getClassificationFromClauseAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2673:1: ( rule__ClassificationFromClause__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2673:2: rule__ClassificationFromClause__Group__0

+            {

+            pushFollow(FOLLOW_rule__ClassificationFromClause__Group__0_in_ruleClassificationFromClause5664);

+            rule__ClassificationFromClause__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassificationFromClauseAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleClassificationFromClause"

+

+

+    // $ANTLR start "entryRuleClassificationToClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2685:1: entryRuleClassificationToClause : ruleClassificationToClause EOF ;

+    public final void entryRuleClassificationToClause() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2686:1: ( ruleClassificationToClause EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2687:1: ruleClassificationToClause EOF

+            {

+             before(grammarAccess.getClassificationToClauseRule()); 

+            pushFollow(FOLLOW_ruleClassificationToClause_in_entryRuleClassificationToClause5691);

+            ruleClassificationToClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassificationToClauseRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleClassificationToClause5698); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleClassificationToClause"

+

+

+    // $ANTLR start "ruleClassificationToClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2694:1: ruleClassificationToClause : ( ( rule__ClassificationToClause__Group__0 ) ) ;

+    public final void ruleClassificationToClause() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2698:2: ( ( ( rule__ClassificationToClause__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2699:1: ( ( rule__ClassificationToClause__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2699:1: ( ( rule__ClassificationToClause__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2700:1: ( rule__ClassificationToClause__Group__0 )

+            {

+             before(grammarAccess.getClassificationToClauseAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2701:1: ( rule__ClassificationToClause__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2701:2: rule__ClassificationToClause__Group__0

+            {

+            pushFollow(FOLLOW_rule__ClassificationToClause__Group__0_in_ruleClassificationToClause5724);

+            rule__ClassificationToClause__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassificationToClauseAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleClassificationToClause"

+

+

+    // $ANTLR start "entryRuleReclassifyAllClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2713:1: entryRuleReclassifyAllClause : ruleReclassifyAllClause EOF ;

+    public final void entryRuleReclassifyAllClause() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2714:1: ( ruleReclassifyAllClause EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2715:1: ruleReclassifyAllClause EOF

+            {

+             before(grammarAccess.getReclassifyAllClauseRule()); 

+            pushFollow(FOLLOW_ruleReclassifyAllClause_in_entryRuleReclassifyAllClause5751);

+            ruleReclassifyAllClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getReclassifyAllClauseRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleReclassifyAllClause5758); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleReclassifyAllClause"

+

+

+    // $ANTLR start "ruleReclassifyAllClause"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2722:1: ruleReclassifyAllClause : ( ( rule__ReclassifyAllClause__Group__0 ) ) ;

+    public final void ruleReclassifyAllClause() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2726:2: ( ( ( rule__ReclassifyAllClause__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2727:1: ( ( rule__ReclassifyAllClause__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2727:1: ( ( rule__ReclassifyAllClause__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2728:1: ( rule__ReclassifyAllClause__Group__0 )

+            {

+             before(grammarAccess.getReclassifyAllClauseAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2729:1: ( rule__ReclassifyAllClause__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2729:2: rule__ReclassifyAllClause__Group__0

+            {

+            pushFollow(FOLLOW_rule__ReclassifyAllClause__Group__0_in_ruleReclassifyAllClause5784);

+            rule__ReclassifyAllClause__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getReclassifyAllClauseAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleReclassifyAllClause"

+

+

+    // $ANTLR start "entryRuleQualifiedNameList"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2741:1: entryRuleQualifiedNameList : ruleQualifiedNameList EOF ;

+    public final void entryRuleQualifiedNameList() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2742:1: ( ruleQualifiedNameList EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2743:1: ruleQualifiedNameList EOF

+            {

+             before(grammarAccess.getQualifiedNameListRule()); 

+            pushFollow(FOLLOW_ruleQualifiedNameList_in_entryRuleQualifiedNameList5811);

+            ruleQualifiedNameList();

+

+            state._fsp--;

+

+             after(grammarAccess.getQualifiedNameListRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleQualifiedNameList5818); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleQualifiedNameList"

+

+

+    // $ANTLR start "ruleQualifiedNameList"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2750:1: ruleQualifiedNameList : ( ( rule__QualifiedNameList__Group__0 ) ) ;

+    public final void ruleQualifiedNameList() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2754:2: ( ( ( rule__QualifiedNameList__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2755:1: ( ( rule__QualifiedNameList__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2755:1: ( ( rule__QualifiedNameList__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2756:1: ( rule__QualifiedNameList__Group__0 )

+            {

+             before(grammarAccess.getQualifiedNameListAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2757:1: ( rule__QualifiedNameList__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2757:2: rule__QualifiedNameList__Group__0

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameList__Group__0_in_ruleQualifiedNameList5844);

+            rule__QualifiedNameList__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getQualifiedNameListAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleQualifiedNameList"

+

+

+    // $ANTLR start "entryRuleInvocationOrAssignementOrDeclarationStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2769:1: entryRuleInvocationOrAssignementOrDeclarationStatement : ruleInvocationOrAssignementOrDeclarationStatement EOF ;

+    public final void entryRuleInvocationOrAssignementOrDeclarationStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2770:1: ( ruleInvocationOrAssignementOrDeclarationStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2771:1: ruleInvocationOrAssignementOrDeclarationStatement EOF

+            {

+             before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementRule()); 

+            pushFollow(FOLLOW_ruleInvocationOrAssignementOrDeclarationStatement_in_entryRuleInvocationOrAssignementOrDeclarationStatement5871);

+            ruleInvocationOrAssignementOrDeclarationStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleInvocationOrAssignementOrDeclarationStatement5878); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleInvocationOrAssignementOrDeclarationStatement"

+

+

+    // $ANTLR start "ruleInvocationOrAssignementOrDeclarationStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2778:1: ruleInvocationOrAssignementOrDeclarationStatement : ( ( rule__InvocationOrAssignementOrDeclarationStatement__Group__0 ) ) ;

+    public final void ruleInvocationOrAssignementOrDeclarationStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2782:2: ( ( ( rule__InvocationOrAssignementOrDeclarationStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2783:1: ( ( rule__InvocationOrAssignementOrDeclarationStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2783:1: ( ( rule__InvocationOrAssignementOrDeclarationStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2784:1: ( rule__InvocationOrAssignementOrDeclarationStatement__Group__0 )

+            {

+             before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2785:1: ( rule__InvocationOrAssignementOrDeclarationStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2785:2: rule__InvocationOrAssignementOrDeclarationStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Group__0_in_ruleInvocationOrAssignementOrDeclarationStatement5904);

+            rule__InvocationOrAssignementOrDeclarationStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleInvocationOrAssignementOrDeclarationStatement"

+

+

+    // $ANTLR start "entryRuleSuperInvocationStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2797:1: entryRuleSuperInvocationStatement : ruleSuperInvocationStatement EOF ;

+    public final void entryRuleSuperInvocationStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2798:1: ( ruleSuperInvocationStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2799:1: ruleSuperInvocationStatement EOF

+            {

+             before(grammarAccess.getSuperInvocationStatementRule()); 

+            pushFollow(FOLLOW_ruleSuperInvocationStatement_in_entryRuleSuperInvocationStatement5931);

+            ruleSuperInvocationStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getSuperInvocationStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleSuperInvocationStatement5938); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleSuperInvocationStatement"

+

+

+    // $ANTLR start "ruleSuperInvocationStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2806:1: ruleSuperInvocationStatement : ( ( rule__SuperInvocationStatement__Group__0 ) ) ;

+    public final void ruleSuperInvocationStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2810:2: ( ( ( rule__SuperInvocationStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2811:1: ( ( rule__SuperInvocationStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2811:1: ( ( rule__SuperInvocationStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2812:1: ( rule__SuperInvocationStatement__Group__0 )

+            {

+             before(grammarAccess.getSuperInvocationStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2813:1: ( rule__SuperInvocationStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2813:2: rule__SuperInvocationStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__SuperInvocationStatement__Group__0_in_ruleSuperInvocationStatement5964);

+            rule__SuperInvocationStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSuperInvocationStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSuperInvocationStatement"

+

+

+    // $ANTLR start "entryRuleThisInvocationStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2825:1: entryRuleThisInvocationStatement : ruleThisInvocationStatement EOF ;

+    public final void entryRuleThisInvocationStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2826:1: ( ruleThisInvocationStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2827:1: ruleThisInvocationStatement EOF

+            {

+             before(grammarAccess.getThisInvocationStatementRule()); 

+            pushFollow(FOLLOW_ruleThisInvocationStatement_in_entryRuleThisInvocationStatement5991);

+            ruleThisInvocationStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getThisInvocationStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleThisInvocationStatement5998); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleThisInvocationStatement"

+

+

+    // $ANTLR start "ruleThisInvocationStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2834:1: ruleThisInvocationStatement : ( ( rule__ThisInvocationStatement__Group__0 ) ) ;

+    public final void ruleThisInvocationStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2838:2: ( ( ( rule__ThisInvocationStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2839:1: ( ( rule__ThisInvocationStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2839:1: ( ( rule__ThisInvocationStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2840:1: ( rule__ThisInvocationStatement__Group__0 )

+            {

+             before(grammarAccess.getThisInvocationStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2841:1: ( rule__ThisInvocationStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2841:2: rule__ThisInvocationStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__ThisInvocationStatement__Group__0_in_ruleThisInvocationStatement6024);

+            rule__ThisInvocationStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getThisInvocationStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleThisInvocationStatement"

+

+

+    // $ANTLR start "entryRuleInstanceCreationInvocationStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2853:1: entryRuleInstanceCreationInvocationStatement : ruleInstanceCreationInvocationStatement EOF ;

+    public final void entryRuleInstanceCreationInvocationStatement() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2854:1: ( ruleInstanceCreationInvocationStatement EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2855:1: ruleInstanceCreationInvocationStatement EOF

+            {

+             before(grammarAccess.getInstanceCreationInvocationStatementRule()); 

+            pushFollow(FOLLOW_ruleInstanceCreationInvocationStatement_in_entryRuleInstanceCreationInvocationStatement6051);

+            ruleInstanceCreationInvocationStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getInstanceCreationInvocationStatementRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleInstanceCreationInvocationStatement6058); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleInstanceCreationInvocationStatement"

+

+

+    // $ANTLR start "ruleInstanceCreationInvocationStatement"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2862:1: ruleInstanceCreationInvocationStatement : ( ( rule__InstanceCreationInvocationStatement__Group__0 ) ) ;

+    public final void ruleInstanceCreationInvocationStatement() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2866:2: ( ( ( rule__InstanceCreationInvocationStatement__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2867:1: ( ( rule__InstanceCreationInvocationStatement__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2867:1: ( ( rule__InstanceCreationInvocationStatement__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2868:1: ( rule__InstanceCreationInvocationStatement__Group__0 )

+            {

+             before(grammarAccess.getInstanceCreationInvocationStatementAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2869:1: ( rule__InstanceCreationInvocationStatement__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2869:2: rule__InstanceCreationInvocationStatement__Group__0

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationInvocationStatement__Group__0_in_ruleInstanceCreationInvocationStatement6084);

+            rule__InstanceCreationInvocationStatement__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInstanceCreationInvocationStatementAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleInstanceCreationInvocationStatement"

+

+

+    // $ANTLR start "entryRuleVariableDeclarationCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2881:1: entryRuleVariableDeclarationCompletion : ruleVariableDeclarationCompletion EOF ;

+    public final void entryRuleVariableDeclarationCompletion() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2882:1: ( ruleVariableDeclarationCompletion EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2883:1: ruleVariableDeclarationCompletion EOF

+            {

+             before(grammarAccess.getVariableDeclarationCompletionRule()); 

+            pushFollow(FOLLOW_ruleVariableDeclarationCompletion_in_entryRuleVariableDeclarationCompletion6111);

+            ruleVariableDeclarationCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getVariableDeclarationCompletionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleVariableDeclarationCompletion6118); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleVariableDeclarationCompletion"

+

+

+    // $ANTLR start "ruleVariableDeclarationCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2890:1: ruleVariableDeclarationCompletion : ( ( rule__VariableDeclarationCompletion__Group__0 ) ) ;

+    public final void ruleVariableDeclarationCompletion() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2894:2: ( ( ( rule__VariableDeclarationCompletion__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2895:1: ( ( rule__VariableDeclarationCompletion__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2895:1: ( ( rule__VariableDeclarationCompletion__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2896:1: ( rule__VariableDeclarationCompletion__Group__0 )

+            {

+             before(grammarAccess.getVariableDeclarationCompletionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2897:1: ( rule__VariableDeclarationCompletion__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2897:2: rule__VariableDeclarationCompletion__Group__0

+            {

+            pushFollow(FOLLOW_rule__VariableDeclarationCompletion__Group__0_in_ruleVariableDeclarationCompletion6144);

+            rule__VariableDeclarationCompletion__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getVariableDeclarationCompletionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleVariableDeclarationCompletion"

+

+

+    // $ANTLR start "entryRuleAssignmentCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2909:1: entryRuleAssignmentCompletion : ruleAssignmentCompletion EOF ;

+    public final void entryRuleAssignmentCompletion() throws RecognitionException {

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2910:1: ( ruleAssignmentCompletion EOF )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2911:1: ruleAssignmentCompletion EOF

+            {

+             before(grammarAccess.getAssignmentCompletionRule()); 

+            pushFollow(FOLLOW_ruleAssignmentCompletion_in_entryRuleAssignmentCompletion6171);

+            ruleAssignmentCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getAssignmentCompletionRule()); 

+            match(input,EOF,FOLLOW_EOF_in_entryRuleAssignmentCompletion6178); 

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+        }

+        return ;

+    }

+    // $ANTLR end "entryRuleAssignmentCompletion"

+

+

+    // $ANTLR start "ruleAssignmentCompletion"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2918:1: ruleAssignmentCompletion : ( ( rule__AssignmentCompletion__Group__0 ) ) ;

+    public final void ruleAssignmentCompletion() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2922:2: ( ( ( rule__AssignmentCompletion__Group__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2923:1: ( ( rule__AssignmentCompletion__Group__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2923:1: ( ( rule__AssignmentCompletion__Group__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2924:1: ( rule__AssignmentCompletion__Group__0 )

+            {

+             before(grammarAccess.getAssignmentCompletionAccess().getGroup()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2925:1: ( rule__AssignmentCompletion__Group__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2925:2: rule__AssignmentCompletion__Group__0

+            {

+            pushFollow(FOLLOW_rule__AssignmentCompletion__Group__0_in_ruleAssignmentCompletion6204);

+            rule__AssignmentCompletion__Group__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAssignmentCompletionAccess().getGroup()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleAssignmentCompletion"

+

+

+    // $ANTLR start "ruleBooleanValue"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2938:1: ruleBooleanValue : ( ( rule__BooleanValue__Alternatives ) ) ;

+    public final void ruleBooleanValue() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2942:1: ( ( ( rule__BooleanValue__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2943:1: ( ( rule__BooleanValue__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2943:1: ( ( rule__BooleanValue__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2944:1: ( rule__BooleanValue__Alternatives )

+            {

+             before(grammarAccess.getBooleanValueAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2945:1: ( rule__BooleanValue__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2945:2: rule__BooleanValue__Alternatives

+            {

+            pushFollow(FOLLOW_rule__BooleanValue__Alternatives_in_ruleBooleanValue6241);

+            rule__BooleanValue__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getBooleanValueAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleBooleanValue"

+

+

+    // $ANTLR start "ruleLinkOperationKind"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2957:1: ruleLinkOperationKind : ( ( rule__LinkOperationKind__Alternatives ) ) ;

+    public final void ruleLinkOperationKind() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2961:1: ( ( ( rule__LinkOperationKind__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2962:1: ( ( rule__LinkOperationKind__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2962:1: ( ( rule__LinkOperationKind__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2963:1: ( rule__LinkOperationKind__Alternatives )

+            {

+             before(grammarAccess.getLinkOperationKindAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2964:1: ( rule__LinkOperationKind__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2964:2: rule__LinkOperationKind__Alternatives

+            {

+            pushFollow(FOLLOW_rule__LinkOperationKind__Alternatives_in_ruleLinkOperationKind6277);

+            rule__LinkOperationKind__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLinkOperationKindAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleLinkOperationKind"

+

+

+    // $ANTLR start "ruleSelectOrRejectOperator"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2976:1: ruleSelectOrRejectOperator : ( ( rule__SelectOrRejectOperator__Alternatives ) ) ;

+    public final void ruleSelectOrRejectOperator() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2980:1: ( ( ( rule__SelectOrRejectOperator__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2981:1: ( ( rule__SelectOrRejectOperator__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2981:1: ( ( rule__SelectOrRejectOperator__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2982:1: ( rule__SelectOrRejectOperator__Alternatives )

+            {

+             before(grammarAccess.getSelectOrRejectOperatorAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2983:1: ( rule__SelectOrRejectOperator__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2983:2: rule__SelectOrRejectOperator__Alternatives

+            {

+            pushFollow(FOLLOW_rule__SelectOrRejectOperator__Alternatives_in_ruleSelectOrRejectOperator6313);

+            rule__SelectOrRejectOperator__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSelectOrRejectOperatorAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleSelectOrRejectOperator"

+

+

+    // $ANTLR start "ruleCollectOrIterateOperator"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2995:1: ruleCollectOrIterateOperator : ( ( rule__CollectOrIterateOperator__Alternatives ) ) ;

+    public final void ruleCollectOrIterateOperator() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:2999:1: ( ( ( rule__CollectOrIterateOperator__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3000:1: ( ( rule__CollectOrIterateOperator__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3000:1: ( ( rule__CollectOrIterateOperator__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3001:1: ( rule__CollectOrIterateOperator__Alternatives )

+            {

+             before(grammarAccess.getCollectOrIterateOperatorAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3002:1: ( rule__CollectOrIterateOperator__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3002:2: rule__CollectOrIterateOperator__Alternatives

+            {

+            pushFollow(FOLLOW_rule__CollectOrIterateOperator__Alternatives_in_ruleCollectOrIterateOperator6349);

+            rule__CollectOrIterateOperator__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getCollectOrIterateOperatorAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleCollectOrIterateOperator"

+

+

+    // $ANTLR start "ruleForAllOrExistsOrOneOperator"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3014:1: ruleForAllOrExistsOrOneOperator : ( ( rule__ForAllOrExistsOrOneOperator__Alternatives ) ) ;

+    public final void ruleForAllOrExistsOrOneOperator() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3018:1: ( ( ( rule__ForAllOrExistsOrOneOperator__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3019:1: ( ( rule__ForAllOrExistsOrOneOperator__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3019:1: ( ( rule__ForAllOrExistsOrOneOperator__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3020:1: ( rule__ForAllOrExistsOrOneOperator__Alternatives )

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3021:1: ( rule__ForAllOrExistsOrOneOperator__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3021:2: rule__ForAllOrExistsOrOneOperator__Alternatives

+            {

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperator__Alternatives_in_ruleForAllOrExistsOrOneOperator6385);

+            rule__ForAllOrExistsOrOneOperator__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleForAllOrExistsOrOneOperator"

+

+

+    // $ANTLR start "ruleAnnotationKind"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3033:1: ruleAnnotationKind : ( ( rule__AnnotationKind__Alternatives ) ) ;

+    public final void ruleAnnotationKind() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3037:1: ( ( ( rule__AnnotationKind__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3038:1: ( ( rule__AnnotationKind__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3038:1: ( ( rule__AnnotationKind__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3039:1: ( rule__AnnotationKind__Alternatives )

+            {

+             before(grammarAccess.getAnnotationKindAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3040:1: ( rule__AnnotationKind__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3040:2: rule__AnnotationKind__Alternatives

+            {

+            pushFollow(FOLLOW_rule__AnnotationKind__Alternatives_in_ruleAnnotationKind6421);

+            rule__AnnotationKind__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAnnotationKindAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleAnnotationKind"

+

+

+    // $ANTLR start "ruleAssignmentOperator"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3052:1: ruleAssignmentOperator : ( ( rule__AssignmentOperator__Alternatives ) ) ;

+    public final void ruleAssignmentOperator() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3056:1: ( ( ( rule__AssignmentOperator__Alternatives ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3057:1: ( ( rule__AssignmentOperator__Alternatives ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3057:1: ( ( rule__AssignmentOperator__Alternatives ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3058:1: ( rule__AssignmentOperator__Alternatives )

+            {

+             before(grammarAccess.getAssignmentOperatorAccess().getAlternatives()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3059:1: ( rule__AssignmentOperator__Alternatives )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3059:2: rule__AssignmentOperator__Alternatives

+            {

+            pushFollow(FOLLOW_rule__AssignmentOperator__Alternatives_in_ruleAssignmentOperator6457);

+            rule__AssignmentOperator__Alternatives();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAssignmentOperatorAccess().getAlternatives()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "ruleAssignmentOperator"

+

+

+    // $ANTLR start "rule__LITERAL__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3070:1: rule__LITERAL__Alternatives : ( ( ruleBOOLEAN_LITERAL ) | ( ruleNUMBER_LITERAL ) | ( ruleSTRING_LITERAL ) );

+    public final void rule__LITERAL__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3074:1: ( ( ruleBOOLEAN_LITERAL ) | ( ruleNUMBER_LITERAL ) | ( ruleSTRING_LITERAL ) )

+            int alt4=3;

+            switch ( input.LA(1) ) {

+            case 33:

+            case 34:

+                {

+                alt4=1;

+                }

+                break;

+            case RULE_INTEGERVALUE:

+            case 27:

+                {

+                alt4=2;

+                }

+                break;

+            case RULE_STRING:

+                {

+                alt4=3;

+                }

+                break;

+            default:

+                NoViableAltException nvae =

+                    new NoViableAltException("", 4, 0, input);

+

+                throw nvae;

+            }

+

+            switch (alt4) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3075:1: ( ruleBOOLEAN_LITERAL )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3075:1: ( ruleBOOLEAN_LITERAL )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3076:1: ruleBOOLEAN_LITERAL

+                    {

+                     before(grammarAccess.getLITERALAccess().getBOOLEAN_LITERALParserRuleCall_0()); 

+                    pushFollow(FOLLOW_ruleBOOLEAN_LITERAL_in_rule__LITERAL__Alternatives6492);

+                    ruleBOOLEAN_LITERAL();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getLITERALAccess().getBOOLEAN_LITERALParserRuleCall_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3081:6: ( ruleNUMBER_LITERAL )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3081:6: ( ruleNUMBER_LITERAL )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3082:1: ruleNUMBER_LITERAL

+                    {

+                     before(grammarAccess.getLITERALAccess().getNUMBER_LITERALParserRuleCall_1()); 

+                    pushFollow(FOLLOW_ruleNUMBER_LITERAL_in_rule__LITERAL__Alternatives6509);

+                    ruleNUMBER_LITERAL();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getLITERALAccess().getNUMBER_LITERALParserRuleCall_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3087:6: ( ruleSTRING_LITERAL )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3087:6: ( ruleSTRING_LITERAL )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3088:1: ruleSTRING_LITERAL

+                    {

+                     before(grammarAccess.getLITERALAccess().getSTRING_LITERALParserRuleCall_2()); 

+                    pushFollow(FOLLOW_ruleSTRING_LITERAL_in_rule__LITERAL__Alternatives6526);

+                    ruleSTRING_LITERAL();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getLITERALAccess().getSTRING_LITERALParserRuleCall_2()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LITERAL__Alternatives"

+

+

+    // $ANTLR start "rule__NUMBER_LITERAL__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3098:1: rule__NUMBER_LITERAL__Alternatives : ( ( ruleINTEGER_LITERAL ) | ( ruleUNLIMITED_LITERAL ) );

+    public final void rule__NUMBER_LITERAL__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3102:1: ( ( ruleINTEGER_LITERAL ) | ( ruleUNLIMITED_LITERAL ) )

+            int alt5=2;

+            int LA5_0 = input.LA(1);

+

+            if ( (LA5_0==RULE_INTEGERVALUE) ) {

+                alt5=1;

+            }

+            else if ( (LA5_0==27) ) {

+                alt5=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 5, 0, input);

+

+                throw nvae;

+            }

+            switch (alt5) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3103:1: ( ruleINTEGER_LITERAL )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3103:1: ( ruleINTEGER_LITERAL )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3104:1: ruleINTEGER_LITERAL

+                    {

+                     before(grammarAccess.getNUMBER_LITERALAccess().getINTEGER_LITERALParserRuleCall_0()); 

+                    pushFollow(FOLLOW_ruleINTEGER_LITERAL_in_rule__NUMBER_LITERAL__Alternatives6558);

+                    ruleINTEGER_LITERAL();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getNUMBER_LITERALAccess().getINTEGER_LITERALParserRuleCall_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3109:6: ( ruleUNLIMITED_LITERAL )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3109:6: ( ruleUNLIMITED_LITERAL )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3110:1: ruleUNLIMITED_LITERAL

+                    {

+                     before(grammarAccess.getNUMBER_LITERALAccess().getUNLIMITED_LITERALParserRuleCall_1()); 

+                    pushFollow(FOLLOW_ruleUNLIMITED_LITERAL_in_rule__NUMBER_LITERAL__Alternatives6575);

+                    ruleUNLIMITED_LITERAL();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getNUMBER_LITERALAccess().getUNLIMITED_LITERALParserRuleCall_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NUMBER_LITERAL__Alternatives"

+

+

+    // $ANTLR start "rule__NameExpression__Alternatives_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3120:1: rule__NameExpression__Alternatives_0 : ( ( ( rule__NameExpression__Group_0_0__0 ) ) | ( ( rule__NameExpression__Group_0_1__0 ) ) );

+    public final void rule__NameExpression__Alternatives_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3124:1: ( ( ( rule__NameExpression__Group_0_0__0 ) ) | ( ( rule__NameExpression__Group_0_1__0 ) ) )

+            int alt6=2;

+            int LA6_0 = input.LA(1);

+

+            if ( ((LA6_0>=12 && LA6_0<=13)) ) {

+                alt6=1;

+            }

+            else if ( (LA6_0==RULE_ID) ) {

+                alt6=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 6, 0, input);

+

+                throw nvae;

+            }

+            switch (alt6) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3125:1: ( ( rule__NameExpression__Group_0_0__0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3125:1: ( ( rule__NameExpression__Group_0_0__0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3126:1: ( rule__NameExpression__Group_0_0__0 )

+                    {

+                     before(grammarAccess.getNameExpressionAccess().getGroup_0_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3127:1: ( rule__NameExpression__Group_0_0__0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3127:2: rule__NameExpression__Group_0_0__0

+                    {

+                    pushFollow(FOLLOW_rule__NameExpression__Group_0_0__0_in_rule__NameExpression__Alternatives_06607);

+                    rule__NameExpression__Group_0_0__0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getNameExpressionAccess().getGroup_0_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3131:6: ( ( rule__NameExpression__Group_0_1__0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3131:6: ( ( rule__NameExpression__Group_0_1__0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3132:1: ( rule__NameExpression__Group_0_1__0 )

+                    {

+                     before(grammarAccess.getNameExpressionAccess().getGroup_0_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3133:1: ( rule__NameExpression__Group_0_1__0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3133:2: rule__NameExpression__Group_0_1__0

+                    {

+                    pushFollow(FOLLOW_rule__NameExpression__Group_0_1__0_in_rule__NameExpression__Alternatives_06625);

+                    rule__NameExpression__Group_0_1__0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getNameExpressionAccess().getGroup_0_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Alternatives_0"

+

+

+    // $ANTLR start "rule__NameExpression__PrefixOpAlternatives_0_0_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3142:1: rule__NameExpression__PrefixOpAlternatives_0_0_0_0 : ( ( '++' ) | ( '--' ) );

+    public final void rule__NameExpression__PrefixOpAlternatives_0_0_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3146:1: ( ( '++' ) | ( '--' ) )

+            int alt7=2;

+            int LA7_0 = input.LA(1);

+

+            if ( (LA7_0==12) ) {

+                alt7=1;

+            }

+            else if ( (LA7_0==13) ) {

+                alt7=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 7, 0, input);

+

+                throw nvae;

+            }

+            switch (alt7) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3147:1: ( '++' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3147:1: ( '++' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3148:1: '++'

+                    {

+                     before(grammarAccess.getNameExpressionAccess().getPrefixOpPlusSignPlusSignKeyword_0_0_0_0_0()); 

+                    match(input,12,FOLLOW_12_in_rule__NameExpression__PrefixOpAlternatives_0_0_0_06659); 

+                     after(grammarAccess.getNameExpressionAccess().getPrefixOpPlusSignPlusSignKeyword_0_0_0_0_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3155:6: ( '--' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3155:6: ( '--' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3156:1: '--'

+                    {

+                     before(grammarAccess.getNameExpressionAccess().getPrefixOpHyphenMinusHyphenMinusKeyword_0_0_0_0_1()); 

+                    match(input,13,FOLLOW_13_in_rule__NameExpression__PrefixOpAlternatives_0_0_0_06679); 

+                     after(grammarAccess.getNameExpressionAccess().getPrefixOpHyphenMinusHyphenMinusKeyword_0_0_0_0_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__PrefixOpAlternatives_0_0_0_0"

+

+

+    // $ANTLR start "rule__NameExpression__Alternatives_0_1_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3168:1: rule__NameExpression__Alternatives_0_1_2 : ( ( ( rule__NameExpression__InvocationCompletionAssignment_0_1_2_0 ) ) | ( ( rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1 ) ) | ( ( rule__NameExpression__PostfixOpAssignment_0_1_2_2 ) ) );

+    public final void rule__NameExpression__Alternatives_0_1_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3172:1: ( ( ( rule__NameExpression__InvocationCompletionAssignment_0_1_2_0 ) ) | ( ( rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1 ) ) | ( ( rule__NameExpression__PostfixOpAssignment_0_1_2_2 ) ) )

+            int alt8=3;

+            switch ( input.LA(1) ) {

+            case 68:

+                {

+                alt8=1;

+                }

+                break;

+            case 78:

+            case 87:

+                {

+                alt8=2;

+                }

+                break;

+            case 12:

+            case 13:

+                {

+                alt8=3;

+                }

+                break;

+            default:

+                NoViableAltException nvae =

+                    new NoViableAltException("", 8, 0, input);

+

+                throw nvae;

+            }

+

+            switch (alt8) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3173:1: ( ( rule__NameExpression__InvocationCompletionAssignment_0_1_2_0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3173:1: ( ( rule__NameExpression__InvocationCompletionAssignment_0_1_2_0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3174:1: ( rule__NameExpression__InvocationCompletionAssignment_0_1_2_0 )

+                    {

+                     before(grammarAccess.getNameExpressionAccess().getInvocationCompletionAssignment_0_1_2_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3175:1: ( rule__NameExpression__InvocationCompletionAssignment_0_1_2_0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3175:2: rule__NameExpression__InvocationCompletionAssignment_0_1_2_0

+                    {

+                    pushFollow(FOLLOW_rule__NameExpression__InvocationCompletionAssignment_0_1_2_0_in_rule__NameExpression__Alternatives_0_1_26713);

+                    rule__NameExpression__InvocationCompletionAssignment_0_1_2_0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getNameExpressionAccess().getInvocationCompletionAssignment_0_1_2_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3179:6: ( ( rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3179:6: ( ( rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3180:1: ( rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1 )

+                    {

+                     before(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionAssignment_0_1_2_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3181:1: ( rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3181:2: rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1

+                    {

+                    pushFollow(FOLLOW_rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1_in_rule__NameExpression__Alternatives_0_1_26731);

+                    rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionAssignment_0_1_2_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3185:6: ( ( rule__NameExpression__PostfixOpAssignment_0_1_2_2 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3185:6: ( ( rule__NameExpression__PostfixOpAssignment_0_1_2_2 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3186:1: ( rule__NameExpression__PostfixOpAssignment_0_1_2_2 )

+                    {

+                     before(grammarAccess.getNameExpressionAccess().getPostfixOpAssignment_0_1_2_2()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3187:1: ( rule__NameExpression__PostfixOpAssignment_0_1_2_2 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3187:2: rule__NameExpression__PostfixOpAssignment_0_1_2_2

+                    {

+                    pushFollow(FOLLOW_rule__NameExpression__PostfixOpAssignment_0_1_2_2_in_rule__NameExpression__Alternatives_0_1_26749);

+                    rule__NameExpression__PostfixOpAssignment_0_1_2_2();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getNameExpressionAccess().getPostfixOpAssignment_0_1_2_2()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Alternatives_0_1_2"

+

+

+    // $ANTLR start "rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3196:1: rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0 : ( ( '++' ) | ( '--' ) );

+    public final void rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3200:1: ( ( '++' ) | ( '--' ) )

+            int alt9=2;

+            int LA9_0 = input.LA(1);

+

+            if ( (LA9_0==12) ) {

+                alt9=1;

+            }

+            else if ( (LA9_0==13) ) {

+                alt9=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 9, 0, input);

+

+                throw nvae;

+            }

+            switch (alt9) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3201:1: ( '++' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3201:1: ( '++' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3202:1: '++'

+                    {

+                     before(grammarAccess.getNameExpressionAccess().getPostfixOpPlusSignPlusSignKeyword_0_1_2_2_0_0()); 

+                    match(input,12,FOLLOW_12_in_rule__NameExpression__PostfixOpAlternatives_0_1_2_2_06783); 

+                     after(grammarAccess.getNameExpressionAccess().getPostfixOpPlusSignPlusSignKeyword_0_1_2_2_0_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3209:6: ( '--' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3209:6: ( '--' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3210:1: '--'

+                    {

+                     before(grammarAccess.getNameExpressionAccess().getPostfixOpHyphenMinusHyphenMinusKeyword_0_1_2_2_0_1()); 

+                    match(input,13,FOLLOW_13_in_rule__NameExpression__PostfixOpAlternatives_0_1_2_2_06803); 

+                     after(grammarAccess.getNameExpressionAccess().getPostfixOpHyphenMinusHyphenMinusKeyword_0_1_2_2_0_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0"

+

+

+    // $ANTLR start "rule__EqualityExpression__OpAlternatives_1_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3222:1: rule__EqualityExpression__OpAlternatives_1_0_0 : ( ( '==' ) | ( '!=' ) );

+    public final void rule__EqualityExpression__OpAlternatives_1_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3226:1: ( ( '==' ) | ( '!=' ) )

+            int alt10=2;

+            int LA10_0 = input.LA(1);

+

+            if ( (LA10_0==14) ) {

+                alt10=1;

+            }

+            else if ( (LA10_0==15) ) {

+                alt10=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 10, 0, input);

+

+                throw nvae;

+            }

+            switch (alt10) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3227:1: ( '==' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3227:1: ( '==' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3228:1: '=='

+                    {

+                     before(grammarAccess.getEqualityExpressionAccess().getOpEqualsSignEqualsSignKeyword_1_0_0_0()); 

+                    match(input,14,FOLLOW_14_in_rule__EqualityExpression__OpAlternatives_1_0_06838); 

+                     after(grammarAccess.getEqualityExpressionAccess().getOpEqualsSignEqualsSignKeyword_1_0_0_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3235:6: ( '!=' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3235:6: ( '!=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3236:1: '!='

+                    {

+                     before(grammarAccess.getEqualityExpressionAccess().getOpExclamationMarkEqualsSignKeyword_1_0_0_1()); 

+                    match(input,15,FOLLOW_15_in_rule__EqualityExpression__OpAlternatives_1_0_06858); 

+                     after(grammarAccess.getEqualityExpressionAccess().getOpExclamationMarkEqualsSignKeyword_1_0_0_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EqualityExpression__OpAlternatives_1_0_0"

+

+

+    // $ANTLR start "rule__ClassificationExpression__OpAlternatives_1_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3248:1: rule__ClassificationExpression__OpAlternatives_1_0_0 : ( ( 'instanceof' ) | ( 'hastype' ) );

+    public final void rule__ClassificationExpression__OpAlternatives_1_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3252:1: ( ( 'instanceof' ) | ( 'hastype' ) )

+            int alt11=2;

+            int LA11_0 = input.LA(1);

+

+            if ( (LA11_0==16) ) {

+                alt11=1;

+            }

+            else if ( (LA11_0==17) ) {

+                alt11=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 11, 0, input);

+

+                throw nvae;

+            }

+            switch (alt11) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3253:1: ( 'instanceof' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3253:1: ( 'instanceof' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3254:1: 'instanceof'

+                    {

+                     before(grammarAccess.getClassificationExpressionAccess().getOpInstanceofKeyword_1_0_0_0()); 

+                    match(input,16,FOLLOW_16_in_rule__ClassificationExpression__OpAlternatives_1_0_06893); 

+                     after(grammarAccess.getClassificationExpressionAccess().getOpInstanceofKeyword_1_0_0_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3261:6: ( 'hastype' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3261:6: ( 'hastype' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3262:1: 'hastype'

+                    {

+                     before(grammarAccess.getClassificationExpressionAccess().getOpHastypeKeyword_1_0_0_1()); 

+                    match(input,17,FOLLOW_17_in_rule__ClassificationExpression__OpAlternatives_1_0_06913); 

+                     after(grammarAccess.getClassificationExpressionAccess().getOpHastypeKeyword_1_0_0_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationExpression__OpAlternatives_1_0_0"

+

+

+    // $ANTLR start "rule__RelationalExpression__OpAlternatives_1_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3274:1: rule__RelationalExpression__OpAlternatives_1_0_0 : ( ( '<' ) | ( '>' ) | ( '<=' ) | ( '>=' ) );

+    public final void rule__RelationalExpression__OpAlternatives_1_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3278:1: ( ( '<' ) | ( '>' ) | ( '<=' ) | ( '>=' ) )

+            int alt12=4;

+            switch ( input.LA(1) ) {

+            case 18:

+                {

+                alt12=1;

+                }

+                break;

+            case 19:

+                {

+                alt12=2;

+                }

+                break;

+            case 20:

+                {

+                alt12=3;

+                }

+                break;

+            case 21:

+                {

+                alt12=4;

+                }

+                break;

+            default:

+                NoViableAltException nvae =

+                    new NoViableAltException("", 12, 0, input);

+

+                throw nvae;

+            }

+

+            switch (alt12) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3279:1: ( '<' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3279:1: ( '<' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3280:1: '<'

+                    {

+                     before(grammarAccess.getRelationalExpressionAccess().getOpLessThanSignKeyword_1_0_0_0()); 

+                    match(input,18,FOLLOW_18_in_rule__RelationalExpression__OpAlternatives_1_0_06948); 

+                     after(grammarAccess.getRelationalExpressionAccess().getOpLessThanSignKeyword_1_0_0_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3287:6: ( '>' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3287:6: ( '>' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3288:1: '>'

+                    {

+                     before(grammarAccess.getRelationalExpressionAccess().getOpGreaterThanSignKeyword_1_0_0_1()); 

+                    match(input,19,FOLLOW_19_in_rule__RelationalExpression__OpAlternatives_1_0_06968); 

+                     after(grammarAccess.getRelationalExpressionAccess().getOpGreaterThanSignKeyword_1_0_0_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3295:6: ( '<=' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3295:6: ( '<=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3296:1: '<='

+                    {

+                     before(grammarAccess.getRelationalExpressionAccess().getOpLessThanSignEqualsSignKeyword_1_0_0_2()); 

+                    match(input,20,FOLLOW_20_in_rule__RelationalExpression__OpAlternatives_1_0_06988); 

+                     after(grammarAccess.getRelationalExpressionAccess().getOpLessThanSignEqualsSignKeyword_1_0_0_2()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 4 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3303:6: ( '>=' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3303:6: ( '>=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3304:1: '>='

+                    {

+                     before(grammarAccess.getRelationalExpressionAccess().getOpGreaterThanSignEqualsSignKeyword_1_0_0_3()); 

+                    match(input,21,FOLLOW_21_in_rule__RelationalExpression__OpAlternatives_1_0_07008); 

+                     after(grammarAccess.getRelationalExpressionAccess().getOpGreaterThanSignEqualsSignKeyword_1_0_0_3()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__RelationalExpression__OpAlternatives_1_0_0"

+

+

+    // $ANTLR start "rule__ShiftExpression__OpAlternatives_1_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3316:1: rule__ShiftExpression__OpAlternatives_1_0_0 : ( ( '<<' ) | ( '>>' ) | ( '>>>' ) );

+    public final void rule__ShiftExpression__OpAlternatives_1_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3320:1: ( ( '<<' ) | ( '>>' ) | ( '>>>' ) )

+            int alt13=3;

+            switch ( input.LA(1) ) {

+            case 22:

+                {

+                alt13=1;

+                }

+                break;

+            case 23:

+                {

+                alt13=2;

+                }

+                break;

+            case 24:

+                {

+                alt13=3;

+                }

+                break;

+            default:

+                NoViableAltException nvae =

+                    new NoViableAltException("", 13, 0, input);

+

+                throw nvae;

+            }

+

+            switch (alt13) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3321:1: ( '<<' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3321:1: ( '<<' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3322:1: '<<'

+                    {

+                     before(grammarAccess.getShiftExpressionAccess().getOpLessThanSignLessThanSignKeyword_1_0_0_0()); 

+                    match(input,22,FOLLOW_22_in_rule__ShiftExpression__OpAlternatives_1_0_07043); 

+                     after(grammarAccess.getShiftExpressionAccess().getOpLessThanSignLessThanSignKeyword_1_0_0_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3329:6: ( '>>' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3329:6: ( '>>' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3330:1: '>>'

+                    {

+                     before(grammarAccess.getShiftExpressionAccess().getOpGreaterThanSignGreaterThanSignKeyword_1_0_0_1()); 

+                    match(input,23,FOLLOW_23_in_rule__ShiftExpression__OpAlternatives_1_0_07063); 

+                     after(grammarAccess.getShiftExpressionAccess().getOpGreaterThanSignGreaterThanSignKeyword_1_0_0_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3337:6: ( '>>>' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3337:6: ( '>>>' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3338:1: '>>>'

+                    {

+                     before(grammarAccess.getShiftExpressionAccess().getOpGreaterThanSignGreaterThanSignGreaterThanSignKeyword_1_0_0_2()); 

+                    match(input,24,FOLLOW_24_in_rule__ShiftExpression__OpAlternatives_1_0_07083); 

+                     after(grammarAccess.getShiftExpressionAccess().getOpGreaterThanSignGreaterThanSignGreaterThanSignKeyword_1_0_0_2()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ShiftExpression__OpAlternatives_1_0_0"

+

+

+    // $ANTLR start "rule__AdditiveExpression__OpAlternatives_1_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3350:1: rule__AdditiveExpression__OpAlternatives_1_0_0 : ( ( '+' ) | ( '-' ) );

+    public final void rule__AdditiveExpression__OpAlternatives_1_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3354:1: ( ( '+' ) | ( '-' ) )

+            int alt14=2;

+            int LA14_0 = input.LA(1);

+

+            if ( (LA14_0==25) ) {

+                alt14=1;

+            }

+            else if ( (LA14_0==26) ) {

+                alt14=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 14, 0, input);

+

+                throw nvae;

+            }

+            switch (alt14) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3355:1: ( '+' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3355:1: ( '+' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3356:1: '+'

+                    {

+                     before(grammarAccess.getAdditiveExpressionAccess().getOpPlusSignKeyword_1_0_0_0()); 

+                    match(input,25,FOLLOW_25_in_rule__AdditiveExpression__OpAlternatives_1_0_07118); 

+                     after(grammarAccess.getAdditiveExpressionAccess().getOpPlusSignKeyword_1_0_0_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3363:6: ( '-' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3363:6: ( '-' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3364:1: '-'

+                    {

+                     before(grammarAccess.getAdditiveExpressionAccess().getOpHyphenMinusKeyword_1_0_0_1()); 

+                    match(input,26,FOLLOW_26_in_rule__AdditiveExpression__OpAlternatives_1_0_07138); 

+                     after(grammarAccess.getAdditiveExpressionAccess().getOpHyphenMinusKeyword_1_0_0_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AdditiveExpression__OpAlternatives_1_0_0"

+

+

+    // $ANTLR start "rule__MultiplicativeExpression__OpAlternatives_1_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3376:1: rule__MultiplicativeExpression__OpAlternatives_1_0_0 : ( ( '*' ) | ( '/' ) | ( '%' ) );

+    public final void rule__MultiplicativeExpression__OpAlternatives_1_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3380:1: ( ( '*' ) | ( '/' ) | ( '%' ) )

+            int alt15=3;

+            switch ( input.LA(1) ) {

+            case 27:

+                {

+                alt15=1;

+                }

+                break;

+            case 28:

+                {

+                alt15=2;

+                }

+                break;

+            case 29:

+                {

+                alt15=3;

+                }

+                break;

+            default:

+                NoViableAltException nvae =

+                    new NoViableAltException("", 15, 0, input);

+

+                throw nvae;

+            }

+

+            switch (alt15) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3381:1: ( '*' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3381:1: ( '*' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3382:1: '*'

+                    {

+                     before(grammarAccess.getMultiplicativeExpressionAccess().getOpAsteriskKeyword_1_0_0_0()); 

+                    match(input,27,FOLLOW_27_in_rule__MultiplicativeExpression__OpAlternatives_1_0_07173); 

+                     after(grammarAccess.getMultiplicativeExpressionAccess().getOpAsteriskKeyword_1_0_0_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3389:6: ( '/' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3389:6: ( '/' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3390:1: '/'

+                    {

+                     before(grammarAccess.getMultiplicativeExpressionAccess().getOpSolidusKeyword_1_0_0_1()); 

+                    match(input,28,FOLLOW_28_in_rule__MultiplicativeExpression__OpAlternatives_1_0_07193); 

+                     after(grammarAccess.getMultiplicativeExpressionAccess().getOpSolidusKeyword_1_0_0_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3397:6: ( '%' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3397:6: ( '%' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3398:1: '%'

+                    {

+                     before(grammarAccess.getMultiplicativeExpressionAccess().getOpPercentSignKeyword_1_0_0_2()); 

+                    match(input,29,FOLLOW_29_in_rule__MultiplicativeExpression__OpAlternatives_1_0_07213); 

+                     after(grammarAccess.getMultiplicativeExpressionAccess().getOpPercentSignKeyword_1_0_0_2()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__MultiplicativeExpression__OpAlternatives_1_0_0"

+

+

+    // $ANTLR start "rule__UnaryExpression__OpAlternatives_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3410:1: rule__UnaryExpression__OpAlternatives_0_0 : ( ( '!' ) | ( '-' ) | ( '+' ) | ( '$' ) | ( '~' ) );

+    public final void rule__UnaryExpression__OpAlternatives_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3414:1: ( ( '!' ) | ( '-' ) | ( '+' ) | ( '$' ) | ( '~' ) )

+            int alt16=5;

+            switch ( input.LA(1) ) {

+            case 30:

+                {

+                alt16=1;

+                }

+                break;

+            case 26:

+                {

+                alt16=2;

+                }

+                break;

+            case 25:

+                {

+                alt16=3;

+                }

+                break;

+            case 31:

+                {

+                alt16=4;

+                }

+                break;

+            case 32:

+                {

+                alt16=5;

+                }

+                break;

+            default:

+                NoViableAltException nvae =

+                    new NoViableAltException("", 16, 0, input);

+

+                throw nvae;

+            }

+

+            switch (alt16) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3415:1: ( '!' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3415:1: ( '!' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3416:1: '!'

+                    {

+                     before(grammarAccess.getUnaryExpressionAccess().getOpExclamationMarkKeyword_0_0_0()); 

+                    match(input,30,FOLLOW_30_in_rule__UnaryExpression__OpAlternatives_0_07248); 

+                     after(grammarAccess.getUnaryExpressionAccess().getOpExclamationMarkKeyword_0_0_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3423:6: ( '-' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3423:6: ( '-' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3424:1: '-'

+                    {

+                     before(grammarAccess.getUnaryExpressionAccess().getOpHyphenMinusKeyword_0_0_1()); 

+                    match(input,26,FOLLOW_26_in_rule__UnaryExpression__OpAlternatives_0_07268); 

+                     after(grammarAccess.getUnaryExpressionAccess().getOpHyphenMinusKeyword_0_0_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3431:6: ( '+' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3431:6: ( '+' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3432:1: '+'

+                    {

+                     before(grammarAccess.getUnaryExpressionAccess().getOpPlusSignKeyword_0_0_2()); 

+                    match(input,25,FOLLOW_25_in_rule__UnaryExpression__OpAlternatives_0_07288); 

+                     after(grammarAccess.getUnaryExpressionAccess().getOpPlusSignKeyword_0_0_2()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 4 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3439:6: ( '$' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3439:6: ( '$' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3440:1: '$'

+                    {

+                     before(grammarAccess.getUnaryExpressionAccess().getOpDollarSignKeyword_0_0_3()); 

+                    match(input,31,FOLLOW_31_in_rule__UnaryExpression__OpAlternatives_0_07308); 

+                     after(grammarAccess.getUnaryExpressionAccess().getOpDollarSignKeyword_0_0_3()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 5 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3447:6: ( '~' )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3447:6: ( '~' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3448:1: '~'

+                    {

+                     before(grammarAccess.getUnaryExpressionAccess().getOpTildeKeyword_0_0_4()); 

+                    match(input,32,FOLLOW_32_in_rule__UnaryExpression__OpAlternatives_0_07328); 

+                     after(grammarAccess.getUnaryExpressionAccess().getOpTildeKeyword_0_0_4()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UnaryExpression__OpAlternatives_0_0"

+

+

+    // $ANTLR start "rule__SuffixExpression__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3460:1: rule__SuffixExpression__Alternatives : ( ( ruleOperationCallExpression ) | ( rulePropertyCallExpression ) | ( ruleLinkOperationExpression ) | ( ruleSequenceOperationExpression ) | ( ruleSequenceReductionExpression ) | ( ruleSequenceExpansionExpression ) | ( ruleClassExtentExpression ) );

+    public final void rule__SuffixExpression__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3464:1: ( ( ruleOperationCallExpression ) | ( rulePropertyCallExpression ) | ( ruleLinkOperationExpression ) | ( ruleSequenceOperationExpression ) | ( ruleSequenceReductionExpression ) | ( ruleSequenceExpansionExpression ) | ( ruleClassExtentExpression ) )

+            int alt17=7;

+            alt17 = dfa17.predict(input);

+            switch (alt17) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3465:1: ( ruleOperationCallExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3465:1: ( ruleOperationCallExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3466:1: ruleOperationCallExpression

+                    {

+                     before(grammarAccess.getSuffixExpressionAccess().getOperationCallExpressionParserRuleCall_0()); 

+                    pushFollow(FOLLOW_ruleOperationCallExpression_in_rule__SuffixExpression__Alternatives7362);

+                    ruleOperationCallExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getSuffixExpressionAccess().getOperationCallExpressionParserRuleCall_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3471:6: ( rulePropertyCallExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3471:6: ( rulePropertyCallExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3472:1: rulePropertyCallExpression

+                    {

+                     before(grammarAccess.getSuffixExpressionAccess().getPropertyCallExpressionParserRuleCall_1()); 

+                    pushFollow(FOLLOW_rulePropertyCallExpression_in_rule__SuffixExpression__Alternatives7379);

+                    rulePropertyCallExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getSuffixExpressionAccess().getPropertyCallExpressionParserRuleCall_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3477:6: ( ruleLinkOperationExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3477:6: ( ruleLinkOperationExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3478:1: ruleLinkOperationExpression

+                    {

+                     before(grammarAccess.getSuffixExpressionAccess().getLinkOperationExpressionParserRuleCall_2()); 

+                    pushFollow(FOLLOW_ruleLinkOperationExpression_in_rule__SuffixExpression__Alternatives7396);

+                    ruleLinkOperationExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getSuffixExpressionAccess().getLinkOperationExpressionParserRuleCall_2()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 4 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3483:6: ( ruleSequenceOperationExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3483:6: ( ruleSequenceOperationExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3484:1: ruleSequenceOperationExpression

+                    {

+                     before(grammarAccess.getSuffixExpressionAccess().getSequenceOperationExpressionParserRuleCall_3()); 

+                    pushFollow(FOLLOW_ruleSequenceOperationExpression_in_rule__SuffixExpression__Alternatives7413);

+                    ruleSequenceOperationExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getSuffixExpressionAccess().getSequenceOperationExpressionParserRuleCall_3()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 5 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3489:6: ( ruleSequenceReductionExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3489:6: ( ruleSequenceReductionExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3490:1: ruleSequenceReductionExpression

+                    {

+                     before(grammarAccess.getSuffixExpressionAccess().getSequenceReductionExpressionParserRuleCall_4()); 

+                    pushFollow(FOLLOW_ruleSequenceReductionExpression_in_rule__SuffixExpression__Alternatives7430);

+                    ruleSequenceReductionExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getSuffixExpressionAccess().getSequenceReductionExpressionParserRuleCall_4()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 6 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3495:6: ( ruleSequenceExpansionExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3495:6: ( ruleSequenceExpansionExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3496:1: ruleSequenceExpansionExpression

+                    {

+                     before(grammarAccess.getSuffixExpressionAccess().getSequenceExpansionExpressionParserRuleCall_5()); 

+                    pushFollow(FOLLOW_ruleSequenceExpansionExpression_in_rule__SuffixExpression__Alternatives7447);

+                    ruleSequenceExpansionExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getSuffixExpressionAccess().getSequenceExpansionExpressionParserRuleCall_5()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 7 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3501:6: ( ruleClassExtentExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3501:6: ( ruleClassExtentExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3502:1: ruleClassExtentExpression

+                    {

+                     before(grammarAccess.getSuffixExpressionAccess().getClassExtentExpressionParserRuleCall_6()); 

+                    pushFollow(FOLLOW_ruleClassExtentExpression_in_rule__SuffixExpression__Alternatives7464);

+                    ruleClassExtentExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getSuffixExpressionAccess().getClassExtentExpressionParserRuleCall_6()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuffixExpression__Alternatives"

+

+

+    // $ANTLR start "rule__SequenceExpansionExpression__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3512:1: rule__SequenceExpansionExpression__Alternatives : ( ( ruleSelectOrRejectOperation ) | ( ruleCollectOrIterateOperation ) | ( ruleForAllOrExistsOrOneOperation ) | ( ruleIsUniqueOperation ) );

+    public final void rule__SequenceExpansionExpression__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3516:1: ( ( ruleSelectOrRejectOperation ) | ( ruleCollectOrIterateOperation ) | ( ruleForAllOrExistsOrOneOperation ) | ( ruleIsUniqueOperation ) )

+            int alt18=4;

+            int LA18_0 = input.LA(1);

+

+            if ( (LA18_0==80) ) {

+                switch ( input.LA(2) ) {

+                case 38:

+                case 39:

+                    {

+                    alt18=1;

+                    }

+                    break;

+                case 40:

+                case 41:

+                    {

+                    alt18=2;

+                    }

+                    break;

+                case 42:

+                case 43:

+                case 44:

+                    {

+                    alt18=3;

+                    }

+                    break;

+                case 82:

+                    {

+                    alt18=4;

+                    }

+                    break;

+                default:

+                    NoViableAltException nvae =

+                        new NoViableAltException("", 18, 1, input);

+

+                    throw nvae;

+                }

+

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 18, 0, input);

+

+                throw nvae;

+            }

+            switch (alt18) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3517:1: ( ruleSelectOrRejectOperation )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3517:1: ( ruleSelectOrRejectOperation )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3518:1: ruleSelectOrRejectOperation

+                    {

+                     before(grammarAccess.getSequenceExpansionExpressionAccess().getSelectOrRejectOperationParserRuleCall_0()); 

+                    pushFollow(FOLLOW_ruleSelectOrRejectOperation_in_rule__SequenceExpansionExpression__Alternatives7496);

+                    ruleSelectOrRejectOperation();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getSequenceExpansionExpressionAccess().getSelectOrRejectOperationParserRuleCall_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3523:6: ( ruleCollectOrIterateOperation )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3523:6: ( ruleCollectOrIterateOperation )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3524:1: ruleCollectOrIterateOperation

+                    {

+                     before(grammarAccess.getSequenceExpansionExpressionAccess().getCollectOrIterateOperationParserRuleCall_1()); 

+                    pushFollow(FOLLOW_ruleCollectOrIterateOperation_in_rule__SequenceExpansionExpression__Alternatives7513);

+                    ruleCollectOrIterateOperation();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getSequenceExpansionExpressionAccess().getCollectOrIterateOperationParserRuleCall_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3529:6: ( ruleForAllOrExistsOrOneOperation )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3529:6: ( ruleForAllOrExistsOrOneOperation )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3530:1: ruleForAllOrExistsOrOneOperation

+                    {

+                     before(grammarAccess.getSequenceExpansionExpressionAccess().getForAllOrExistsOrOneOperationParserRuleCall_2()); 

+                    pushFollow(FOLLOW_ruleForAllOrExistsOrOneOperation_in_rule__SequenceExpansionExpression__Alternatives7530);

+                    ruleForAllOrExistsOrOneOperation();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getSequenceExpansionExpressionAccess().getForAllOrExistsOrOneOperationParserRuleCall_2()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 4 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3535:6: ( ruleIsUniqueOperation )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3535:6: ( ruleIsUniqueOperation )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3536:1: ruleIsUniqueOperation

+                    {

+                     before(grammarAccess.getSequenceExpansionExpressionAccess().getIsUniqueOperationParserRuleCall_3()); 

+                    pushFollow(FOLLOW_ruleIsUniqueOperation_in_rule__SequenceExpansionExpression__Alternatives7547);

+                    ruleIsUniqueOperation();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getSequenceExpansionExpressionAccess().getIsUniqueOperationParserRuleCall_3()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceExpansionExpression__Alternatives"

+

+

+    // $ANTLR start "rule__ValueSpecification__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3546:1: rule__ValueSpecification__Alternatives : ( ( ruleNameExpression ) | ( ruleLITERAL ) | ( ruleThisExpression ) | ( ruleSuperInvocationExpression ) | ( ruleInstanceCreationExpression ) | ( ruleParenthesizedExpression ) | ( ruleNullExpression ) );

+    public final void rule__ValueSpecification__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3550:1: ( ( ruleNameExpression ) | ( ruleLITERAL ) | ( ruleThisExpression ) | ( ruleSuperInvocationExpression ) | ( ruleInstanceCreationExpression ) | ( ruleParenthesizedExpression ) | ( ruleNullExpression ) )

+            int alt19=7;

+            switch ( input.LA(1) ) {

+            case RULE_ID:

+            case 12:

+            case 13:

+                {

+                alt19=1;

+                }

+                break;

+            case RULE_INTEGERVALUE:

+            case RULE_STRING:

+            case 27:

+            case 33:

+            case 34:

+                {

+                alt19=2;

+                }

+                break;

+            case 84:

+                {

+                alt19=3;

+                }

+                break;

+            case 85:

+                {

+                alt19=4;

+                }

+                break;

+            case 86:

+                {

+                alt19=5;

+                }

+                break;

+            case 68:

+                {

+                alt19=6;

+                }

+                break;

+            case 83:

+                {

+                alt19=7;

+                }

+                break;

+            default:

+                NoViableAltException nvae =

+                    new NoViableAltException("", 19, 0, input);

+

+                throw nvae;

+            }

+

+            switch (alt19) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3551:1: ( ruleNameExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3551:1: ( ruleNameExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3552:1: ruleNameExpression

+                    {

+                     before(grammarAccess.getValueSpecificationAccess().getNameExpressionParserRuleCall_0()); 

+                    pushFollow(FOLLOW_ruleNameExpression_in_rule__ValueSpecification__Alternatives7579);

+                    ruleNameExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getValueSpecificationAccess().getNameExpressionParserRuleCall_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3557:6: ( ruleLITERAL )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3557:6: ( ruleLITERAL )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3558:1: ruleLITERAL

+                    {

+                     before(grammarAccess.getValueSpecificationAccess().getLITERALParserRuleCall_1()); 

+                    pushFollow(FOLLOW_ruleLITERAL_in_rule__ValueSpecification__Alternatives7596);

+                    ruleLITERAL();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getValueSpecificationAccess().getLITERALParserRuleCall_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3563:6: ( ruleThisExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3563:6: ( ruleThisExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3564:1: ruleThisExpression

+                    {

+                     before(grammarAccess.getValueSpecificationAccess().getThisExpressionParserRuleCall_2()); 

+                    pushFollow(FOLLOW_ruleThisExpression_in_rule__ValueSpecification__Alternatives7613);

+                    ruleThisExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getValueSpecificationAccess().getThisExpressionParserRuleCall_2()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 4 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3569:6: ( ruleSuperInvocationExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3569:6: ( ruleSuperInvocationExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3570:1: ruleSuperInvocationExpression

+                    {

+                     before(grammarAccess.getValueSpecificationAccess().getSuperInvocationExpressionParserRuleCall_3()); 

+                    pushFollow(FOLLOW_ruleSuperInvocationExpression_in_rule__ValueSpecification__Alternatives7630);

+                    ruleSuperInvocationExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getValueSpecificationAccess().getSuperInvocationExpressionParserRuleCall_3()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 5 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3575:6: ( ruleInstanceCreationExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3575:6: ( ruleInstanceCreationExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3576:1: ruleInstanceCreationExpression

+                    {

+                     before(grammarAccess.getValueSpecificationAccess().getInstanceCreationExpressionParserRuleCall_4()); 

+                    pushFollow(FOLLOW_ruleInstanceCreationExpression_in_rule__ValueSpecification__Alternatives7647);

+                    ruleInstanceCreationExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getValueSpecificationAccess().getInstanceCreationExpressionParserRuleCall_4()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 6 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3581:6: ( ruleParenthesizedExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3581:6: ( ruleParenthesizedExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3582:1: ruleParenthesizedExpression

+                    {

+                     before(grammarAccess.getValueSpecificationAccess().getParenthesizedExpressionParserRuleCall_5()); 

+                    pushFollow(FOLLOW_ruleParenthesizedExpression_in_rule__ValueSpecification__Alternatives7664);

+                    ruleParenthesizedExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getValueSpecificationAccess().getParenthesizedExpressionParserRuleCall_5()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 7 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3587:6: ( ruleNullExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3587:6: ( ruleNullExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3588:1: ruleNullExpression

+                    {

+                     before(grammarAccess.getValueSpecificationAccess().getNullExpressionParserRuleCall_6()); 

+                    pushFollow(FOLLOW_ruleNullExpression_in_rule__ValueSpecification__Alternatives7681);

+                    ruleNullExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getValueSpecificationAccess().getNullExpressionParserRuleCall_6()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ValueSpecification__Alternatives"

+

+

+    // $ANTLR start "rule__NonLiteralValueSpecification__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3598:1: rule__NonLiteralValueSpecification__Alternatives : ( ( ruleNameExpression ) | ( ruleParenthesizedExpression ) | ( ruleInstanceCreationExpression ) | ( ruleThisExpression ) | ( ruleSuperInvocationExpression ) );

+    public final void rule__NonLiteralValueSpecification__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3602:1: ( ( ruleNameExpression ) | ( ruleParenthesizedExpression ) | ( ruleInstanceCreationExpression ) | ( ruleThisExpression ) | ( ruleSuperInvocationExpression ) )

+            int alt20=5;

+            switch ( input.LA(1) ) {

+            case RULE_ID:

+            case 12:

+            case 13:

+                {

+                alt20=1;

+                }

+                break;

+            case 68:

+                {

+                alt20=2;

+                }

+                break;

+            case 86:

+                {

+                alt20=3;

+                }

+                break;

+            case 84:

+                {

+                alt20=4;

+                }

+                break;

+            case 85:

+                {

+                alt20=5;

+                }

+                break;

+            default:

+                NoViableAltException nvae =

+                    new NoViableAltException("", 20, 0, input);

+

+                throw nvae;

+            }

+

+            switch (alt20) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3603:1: ( ruleNameExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3603:1: ( ruleNameExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3604:1: ruleNameExpression

+                    {

+                     before(grammarAccess.getNonLiteralValueSpecificationAccess().getNameExpressionParserRuleCall_0()); 

+                    pushFollow(FOLLOW_ruleNameExpression_in_rule__NonLiteralValueSpecification__Alternatives7713);

+                    ruleNameExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getNonLiteralValueSpecificationAccess().getNameExpressionParserRuleCall_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3609:6: ( ruleParenthesizedExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3609:6: ( ruleParenthesizedExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3610:1: ruleParenthesizedExpression

+                    {

+                     before(grammarAccess.getNonLiteralValueSpecificationAccess().getParenthesizedExpressionParserRuleCall_1()); 

+                    pushFollow(FOLLOW_ruleParenthesizedExpression_in_rule__NonLiteralValueSpecification__Alternatives7730);

+                    ruleParenthesizedExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getNonLiteralValueSpecificationAccess().getParenthesizedExpressionParserRuleCall_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3615:6: ( ruleInstanceCreationExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3615:6: ( ruleInstanceCreationExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3616:1: ruleInstanceCreationExpression

+                    {

+                     before(grammarAccess.getNonLiteralValueSpecificationAccess().getInstanceCreationExpressionParserRuleCall_2()); 

+                    pushFollow(FOLLOW_ruleInstanceCreationExpression_in_rule__NonLiteralValueSpecification__Alternatives7747);

+                    ruleInstanceCreationExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getNonLiteralValueSpecificationAccess().getInstanceCreationExpressionParserRuleCall_2()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 4 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3621:6: ( ruleThisExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3621:6: ( ruleThisExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3622:1: ruleThisExpression

+                    {

+                     before(grammarAccess.getNonLiteralValueSpecificationAccess().getThisExpressionParserRuleCall_3()); 

+                    pushFollow(FOLLOW_ruleThisExpression_in_rule__NonLiteralValueSpecification__Alternatives7764);

+                    ruleThisExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getNonLiteralValueSpecificationAccess().getThisExpressionParserRuleCall_3()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 5 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3627:6: ( ruleSuperInvocationExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3627:6: ( ruleSuperInvocationExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3628:1: ruleSuperInvocationExpression

+                    {

+                     before(grammarAccess.getNonLiteralValueSpecificationAccess().getSuperInvocationExpressionParserRuleCall_4()); 

+                    pushFollow(FOLLOW_ruleSuperInvocationExpression_in_rule__NonLiteralValueSpecification__Alternatives7781);

+                    ruleSuperInvocationExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getNonLiteralValueSpecificationAccess().getSuperInvocationExpressionParserRuleCall_4()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NonLiteralValueSpecification__Alternatives"

+

+

+    // $ANTLR start "rule__ParenthesizedExpression__Alternatives_3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3638:1: rule__ParenthesizedExpression__Alternatives_3 : ( ( ( rule__ParenthesizedExpression__CastedAssignment_3_0 ) ) | ( ( rule__ParenthesizedExpression__SuffixAssignment_3_1 ) ) );

+    public final void rule__ParenthesizedExpression__Alternatives_3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3642:1: ( ( ( rule__ParenthesizedExpression__CastedAssignment_3_0 ) ) | ( ( rule__ParenthesizedExpression__SuffixAssignment_3_1 ) ) )

+            int alt21=2;

+            int LA21_0 = input.LA(1);

+

+            if ( (LA21_0==RULE_ID||(LA21_0>=12 && LA21_0<=13)||LA21_0==68||(LA21_0>=84 && LA21_0<=86)) ) {

+                alt21=1;

+            }

+            else if ( (LA21_0==77||LA21_0==80) ) {

+                alt21=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 21, 0, input);

+

+                throw nvae;

+            }

+            switch (alt21) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3643:1: ( ( rule__ParenthesizedExpression__CastedAssignment_3_0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3643:1: ( ( rule__ParenthesizedExpression__CastedAssignment_3_0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3644:1: ( rule__ParenthesizedExpression__CastedAssignment_3_0 )

+                    {

+                     before(grammarAccess.getParenthesizedExpressionAccess().getCastedAssignment_3_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3645:1: ( rule__ParenthesizedExpression__CastedAssignment_3_0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3645:2: rule__ParenthesizedExpression__CastedAssignment_3_0

+                    {

+                    pushFollow(FOLLOW_rule__ParenthesizedExpression__CastedAssignment_3_0_in_rule__ParenthesizedExpression__Alternatives_37813);

+                    rule__ParenthesizedExpression__CastedAssignment_3_0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getParenthesizedExpressionAccess().getCastedAssignment_3_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3649:6: ( ( rule__ParenthesizedExpression__SuffixAssignment_3_1 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3649:6: ( ( rule__ParenthesizedExpression__SuffixAssignment_3_1 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3650:1: ( rule__ParenthesizedExpression__SuffixAssignment_3_1 )

+                    {

+                     before(grammarAccess.getParenthesizedExpressionAccess().getSuffixAssignment_3_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3651:1: ( rule__ParenthesizedExpression__SuffixAssignment_3_1 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3651:2: rule__ParenthesizedExpression__SuffixAssignment_3_1

+                    {

+                    pushFollow(FOLLOW_rule__ParenthesizedExpression__SuffixAssignment_3_1_in_rule__ParenthesizedExpression__Alternatives_37831);

+                    rule__ParenthesizedExpression__SuffixAssignment_3_1();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getParenthesizedExpressionAccess().getSuffixAssignment_3_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ParenthesizedExpression__Alternatives_3"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__Alternatives_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3660:1: rule__SuperInvocationExpression__Alternatives_1 : ( ( ( rule__SuperInvocationExpression__TupleAssignment_1_0 ) ) | ( ( rule__SuperInvocationExpression__Group_1_1__0 ) ) );

+    public final void rule__SuperInvocationExpression__Alternatives_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3664:1: ( ( ( rule__SuperInvocationExpression__TupleAssignment_1_0 ) ) | ( ( rule__SuperInvocationExpression__Group_1_1__0 ) ) )

+            int alt22=2;

+            int LA22_0 = input.LA(1);

+

+            if ( (LA22_0==68) ) {

+                alt22=1;

+            }

+            else if ( (LA22_0==77) ) {

+                alt22=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 22, 0, input);

+

+                throw nvae;

+            }

+            switch (alt22) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3665:1: ( ( rule__SuperInvocationExpression__TupleAssignment_1_0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3665:1: ( ( rule__SuperInvocationExpression__TupleAssignment_1_0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3666:1: ( rule__SuperInvocationExpression__TupleAssignment_1_0 )

+                    {

+                     before(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3667:1: ( rule__SuperInvocationExpression__TupleAssignment_1_0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3667:2: rule__SuperInvocationExpression__TupleAssignment_1_0

+                    {

+                    pushFollow(FOLLOW_rule__SuperInvocationExpression__TupleAssignment_1_0_in_rule__SuperInvocationExpression__Alternatives_17864);

+                    rule__SuperInvocationExpression__TupleAssignment_1_0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3671:6: ( ( rule__SuperInvocationExpression__Group_1_1__0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3671:6: ( ( rule__SuperInvocationExpression__Group_1_1__0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3672:1: ( rule__SuperInvocationExpression__Group_1_1__0 )

+                    {

+                     before(grammarAccess.getSuperInvocationExpressionAccess().getGroup_1_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3673:1: ( rule__SuperInvocationExpression__Group_1_1__0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3673:2: rule__SuperInvocationExpression__Group_1_1__0

+                    {

+                    pushFollow(FOLLOW_rule__SuperInvocationExpression__Group_1_1__0_in_rule__SuperInvocationExpression__Alternatives_17882);

+                    rule__SuperInvocationExpression__Group_1_1__0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getSuperInvocationExpressionAccess().getGroup_1_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__Alternatives_1"

+

+

+    // $ANTLR start "rule__SequenceConstructionOrAccessCompletion__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3682:1: rule__SequenceConstructionOrAccessCompletion__Alternatives : ( ( ( rule__SequenceConstructionOrAccessCompletion__Group_0__0 ) ) | ( ( rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1 ) ) );

+    public final void rule__SequenceConstructionOrAccessCompletion__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3686:1: ( ( ( rule__SequenceConstructionOrAccessCompletion__Group_0__0 ) ) | ( ( rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1 ) ) )

+            int alt23=2;

+            int LA23_0 = input.LA(1);

+

+            if ( (LA23_0==78) ) {

+                alt23=1;

+            }

+            else if ( (LA23_0==87) ) {

+                alt23=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 23, 0, input);

+

+                throw nvae;

+            }

+            switch (alt23) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3687:1: ( ( rule__SequenceConstructionOrAccessCompletion__Group_0__0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3687:1: ( ( rule__SequenceConstructionOrAccessCompletion__Group_0__0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3688:1: ( rule__SequenceConstructionOrAccessCompletion__Group_0__0 )

+                    {

+                     before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getGroup_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3689:1: ( rule__SequenceConstructionOrAccessCompletion__Group_0__0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3689:2: rule__SequenceConstructionOrAccessCompletion__Group_0__0

+                    {

+                    pushFollow(FOLLOW_rule__SequenceConstructionOrAccessCompletion__Group_0__0_in_rule__SequenceConstructionOrAccessCompletion__Alternatives7915);

+                    rule__SequenceConstructionOrAccessCompletion__Group_0__0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getGroup_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3693:6: ( ( rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3693:6: ( ( rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3694:1: ( rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1 )

+                    {

+                     before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionAssignment_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3695:1: ( rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3695:2: rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1

+                    {

+                    pushFollow(FOLLOW_rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1_in_rule__SequenceConstructionOrAccessCompletion__Alternatives7933);

+                    rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionAssignment_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionOrAccessCompletion__Alternatives"

+

+

+    // $ANTLR start "rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3704:1: rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1 : ( ( ( rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0 ) ) | ( ( rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1 ) ) );

+    public final void rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3708:1: ( ( ( rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0 ) ) | ( ( rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1 ) ) )

+            int alt24=2;

+            int LA24_0 = input.LA(1);

+

+            if ( ((LA24_0>=RULE_INTEGERVALUE && LA24_0<=RULE_ID)||(LA24_0>=12 && LA24_0<=13)||(LA24_0>=25 && LA24_0<=27)||(LA24_0>=30 && LA24_0<=34)||LA24_0==68||(LA24_0>=83 && LA24_0<=86)) ) {

+                alt24=1;

+            }

+            else if ( (LA24_0==79) ) {

+                alt24=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 24, 0, input);

+

+                throw nvae;

+            }

+            switch (alt24) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3709:1: ( ( rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3709:1: ( ( rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3710:1: ( rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0 )

+                    {

+                     before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAssignment_0_1_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3711:1: ( rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3711:2: rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0

+                    {

+                    pushFollow(FOLLOW_rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0_in_rule__SequenceConstructionOrAccessCompletion__Alternatives_0_17966);

+                    rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAssignment_0_1_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3715:6: ( ( rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3715:6: ( ( rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3716:1: ( rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1 )

+                    {

+                     before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionAssignment_0_1_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3717:1: ( rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3717:2: rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1

+                    {

+                    pushFollow(FOLLOW_rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1_in_rule__SequenceConstructionOrAccessCompletion__Alternatives_0_17984);

+                    rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionAssignment_0_1_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Alternatives_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3726:1: rule__SequenceConstructionExpression__Alternatives_2 : ( ( ( rule__SequenceConstructionExpression__Group_2_0__0 )* ) | ( ( rule__SequenceConstructionExpression__Group_2_1__0 ) ) );

+    public final void rule__SequenceConstructionExpression__Alternatives_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3730:1: ( ( ( rule__SequenceConstructionExpression__Group_2_0__0 )* ) | ( ( rule__SequenceConstructionExpression__Group_2_1__0 ) ) )

+            int alt26=2;

+            int LA26_0 = input.LA(1);

+

+            if ( (LA26_0==66||LA26_0==88) ) {

+                alt26=1;

+            }

+            else if ( (LA26_0==89) ) {

+                alt26=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 26, 0, input);

+

+                throw nvae;

+            }

+            switch (alt26) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3731:1: ( ( rule__SequenceConstructionExpression__Group_2_0__0 )* )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3731:1: ( ( rule__SequenceConstructionExpression__Group_2_0__0 )* )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3732:1: ( rule__SequenceConstructionExpression__Group_2_0__0 )*

+                    {

+                     before(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3733:1: ( rule__SequenceConstructionExpression__Group_2_0__0 )*

+                    loop25:

+                    do {

+                        int alt25=2;

+                        int LA25_0 = input.LA(1);

+

+                        if ( (LA25_0==66) ) {

+                            alt25=1;

+                        }

+

+

+                        switch (alt25) {

+                    	case 1 :

+                    	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3733:2: rule__SequenceConstructionExpression__Group_2_0__0

+                    	    {

+                    	    pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group_2_0__0_in_rule__SequenceConstructionExpression__Alternatives_28017);

+                    	    rule__SequenceConstructionExpression__Group_2_0__0();

+

+                    	    state._fsp--;

+

+

+                    	    }

+                    	    break;

+

+                    	default :

+                    	    break loop25;

+                        }

+                    } while (true);

+

+                     after(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3737:6: ( ( rule__SequenceConstructionExpression__Group_2_1__0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3737:6: ( ( rule__SequenceConstructionExpression__Group_2_1__0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3738:1: ( rule__SequenceConstructionExpression__Group_2_1__0 )

+                    {

+                     before(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3739:1: ( rule__SequenceConstructionExpression__Group_2_1__0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3739:2: rule__SequenceConstructionExpression__Group_2_1__0

+                    {

+                    pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group_2_1__0_in_rule__SequenceConstructionExpression__Alternatives_28036);

+                    rule__SequenceConstructionExpression__Group_2_1__0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getSequenceConstructionExpressionAccess().getGroup_2_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Alternatives_2"

+

+

+    // $ANTLR start "rule__SequenceElement__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3748:1: rule__SequenceElement__Alternatives : ( ( ruleExpression ) | ( ruleSequenceConstructionExpression ) );

+    public final void rule__SequenceElement__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3752:1: ( ( ruleExpression ) | ( ruleSequenceConstructionExpression ) )

+            int alt27=2;

+            int LA27_0 = input.LA(1);

+

+            if ( ((LA27_0>=RULE_INTEGERVALUE && LA27_0<=RULE_ID)||(LA27_0>=12 && LA27_0<=13)||(LA27_0>=25 && LA27_0<=27)||(LA27_0>=30 && LA27_0<=34)||LA27_0==68||(LA27_0>=83 && LA27_0<=86)) ) {

+                alt27=1;

+            }

+            else if ( (LA27_0==87) ) {

+                alt27=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 27, 0, input);

+

+                throw nvae;

+            }

+            switch (alt27) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3753:1: ( ruleExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3753:1: ( ruleExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3754:1: ruleExpression

+                    {

+                     before(grammarAccess.getSequenceElementAccess().getExpressionParserRuleCall_0()); 

+                    pushFollow(FOLLOW_ruleExpression_in_rule__SequenceElement__Alternatives8069);

+                    ruleExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getSequenceElementAccess().getExpressionParserRuleCall_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3759:6: ( ruleSequenceConstructionExpression )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3759:6: ( ruleSequenceConstructionExpression )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3760:1: ruleSequenceConstructionExpression

+                    {

+                     before(grammarAccess.getSequenceElementAccess().getSequenceConstructionExpressionParserRuleCall_1()); 

+                    pushFollow(FOLLOW_ruleSequenceConstructionExpression_in_rule__SequenceElement__Alternatives8086);

+                    ruleSequenceConstructionExpression();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getSequenceElementAccess().getSequenceConstructionExpressionParserRuleCall_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceElement__Alternatives"

+

+

+    // $ANTLR start "rule__DocumentedStatement__CommentAlternatives_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3770:1: rule__DocumentedStatement__CommentAlternatives_0_0 : ( ( RULE_ML_COMMENT ) | ( RULE_SL_COMMENT ) );

+    public final void rule__DocumentedStatement__CommentAlternatives_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3774:1: ( ( RULE_ML_COMMENT ) | ( RULE_SL_COMMENT ) )

+            int alt28=2;

+            int LA28_0 = input.LA(1);

+

+            if ( (LA28_0==RULE_ML_COMMENT) ) {

+                alt28=1;

+            }

+            else if ( (LA28_0==RULE_SL_COMMENT) ) {

+                alt28=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 28, 0, input);

+

+                throw nvae;

+            }

+            switch (alt28) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3775:1: ( RULE_ML_COMMENT )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3775:1: ( RULE_ML_COMMENT )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3776:1: RULE_ML_COMMENT

+                    {

+                     before(grammarAccess.getDocumentedStatementAccess().getCommentML_COMMENTTerminalRuleCall_0_0_0()); 

+                    match(input,RULE_ML_COMMENT,FOLLOW_RULE_ML_COMMENT_in_rule__DocumentedStatement__CommentAlternatives_0_08118); 

+                     after(grammarAccess.getDocumentedStatementAccess().getCommentML_COMMENTTerminalRuleCall_0_0_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3781:6: ( RULE_SL_COMMENT )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3781:6: ( RULE_SL_COMMENT )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3782:1: RULE_SL_COMMENT

+                    {

+                     before(grammarAccess.getDocumentedStatementAccess().getCommentSL_COMMENTTerminalRuleCall_0_0_1()); 

+                    match(input,RULE_SL_COMMENT,FOLLOW_RULE_SL_COMMENT_in_rule__DocumentedStatement__CommentAlternatives_0_08135); 

+                     after(grammarAccess.getDocumentedStatementAccess().getCommentSL_COMMENTTerminalRuleCall_0_0_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DocumentedStatement__CommentAlternatives_0_0"

+

+

+    // $ANTLR start "rule__Statement__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3792:1: rule__Statement__Alternatives : ( ( ruleAnnotatedStatement ) | ( ruleInlineStatement ) | ( ruleBlockStatement ) | ( ruleEmptyStatement ) | ( ruleLocalNameDeclarationStatement ) | ( ruleIfStatement ) | ( ruleSwitchStatement ) | ( ruleWhileStatement ) | ( ruleDoStatement ) | ( ruleForStatement ) | ( ruleBreakStatement ) | ( ruleReturnStatement ) | ( ruleAcceptStatement ) | ( ruleClassifyStatement ) | ( ruleInvocationOrAssignementOrDeclarationStatement ) | ( ruleSuperInvocationStatement ) | ( ruleThisInvocationStatement ) | ( ruleInstanceCreationInvocationStatement ) );

+    public final void rule__Statement__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3796:1: ( ( ruleAnnotatedStatement ) | ( ruleInlineStatement ) | ( ruleBlockStatement ) | ( ruleEmptyStatement ) | ( ruleLocalNameDeclarationStatement ) | ( ruleIfStatement ) | ( ruleSwitchStatement ) | ( ruleWhileStatement ) | ( ruleDoStatement ) | ( ruleForStatement ) | ( ruleBreakStatement ) | ( ruleReturnStatement ) | ( ruleAcceptStatement ) | ( ruleClassifyStatement ) | ( ruleInvocationOrAssignementOrDeclarationStatement ) | ( ruleSuperInvocationStatement ) | ( ruleThisInvocationStatement ) | ( ruleInstanceCreationInvocationStatement ) )

+            int alt29=18;

+            switch ( input.LA(1) ) {

+            case 94:

+                {

+                alt29=1;

+                }

+                break;

+            case 91:

+                {

+                alt29=2;

+                }

+                break;

+            case 87:

+                {

+                alt29=3;

+                }

+                break;

+            case 95:

+                {

+                alt29=4;

+                }

+                break;

+            case 96:

+                {

+                alt29=5;

+                }

+                break;

+            case 97:

+                {

+                alt29=6;

+                }

+                break;

+            case 100:

+                {

+                alt29=7;

+                }

+                break;

+            case 103:

+                {

+                alt29=8;

+                }

+                break;

+            case 104:

+                {

+                alt29=9;

+                }

+                break;

+            case 105:

+                {

+                alt29=10;

+                }

+                break;

+            case 107:

+                {

+                alt29=11;

+                }

+                break;

+            case 108:

+                {

+                alt29=12;

+                }

+                break;

+            case 109:

+                {

+                alt29=13;

+                }

+                break;

+            case 110:

+                {

+                alt29=14;

+                }

+                break;

+            case RULE_ID:

+            case 12:

+            case 13:

+                {

+                alt29=15;

+                }

+                break;

+            case 85:

+                {

+                alt29=16;

+                }

+                break;

+            case 84:

+                {

+                alt29=17;

+                }

+                break;

+            case 86:

+                {

+                alt29=18;

+                }

+                break;

+            default:

+                NoViableAltException nvae =

+                    new NoViableAltException("", 29, 0, input);

+

+                throw nvae;

+            }

+

+            switch (alt29) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3797:1: ( ruleAnnotatedStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3797:1: ( ruleAnnotatedStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3798:1: ruleAnnotatedStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getAnnotatedStatementParserRuleCall_0()); 

+                    pushFollow(FOLLOW_ruleAnnotatedStatement_in_rule__Statement__Alternatives8167);

+                    ruleAnnotatedStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getAnnotatedStatementParserRuleCall_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3803:6: ( ruleInlineStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3803:6: ( ruleInlineStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3804:1: ruleInlineStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getInlineStatementParserRuleCall_1()); 

+                    pushFollow(FOLLOW_ruleInlineStatement_in_rule__Statement__Alternatives8184);

+                    ruleInlineStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getInlineStatementParserRuleCall_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3809:6: ( ruleBlockStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3809:6: ( ruleBlockStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3810:1: ruleBlockStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getBlockStatementParserRuleCall_2()); 

+                    pushFollow(FOLLOW_ruleBlockStatement_in_rule__Statement__Alternatives8201);

+                    ruleBlockStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getBlockStatementParserRuleCall_2()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 4 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3815:6: ( ruleEmptyStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3815:6: ( ruleEmptyStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3816:1: ruleEmptyStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getEmptyStatementParserRuleCall_3()); 

+                    pushFollow(FOLLOW_ruleEmptyStatement_in_rule__Statement__Alternatives8218);

+                    ruleEmptyStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getEmptyStatementParserRuleCall_3()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 5 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3821:6: ( ruleLocalNameDeclarationStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3821:6: ( ruleLocalNameDeclarationStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3822:1: ruleLocalNameDeclarationStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getLocalNameDeclarationStatementParserRuleCall_4()); 

+                    pushFollow(FOLLOW_ruleLocalNameDeclarationStatement_in_rule__Statement__Alternatives8235);

+                    ruleLocalNameDeclarationStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getLocalNameDeclarationStatementParserRuleCall_4()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 6 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3827:6: ( ruleIfStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3827:6: ( ruleIfStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3828:1: ruleIfStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getIfStatementParserRuleCall_5()); 

+                    pushFollow(FOLLOW_ruleIfStatement_in_rule__Statement__Alternatives8252);

+                    ruleIfStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getIfStatementParserRuleCall_5()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 7 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3833:6: ( ruleSwitchStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3833:6: ( ruleSwitchStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3834:1: ruleSwitchStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getSwitchStatementParserRuleCall_6()); 

+                    pushFollow(FOLLOW_ruleSwitchStatement_in_rule__Statement__Alternatives8269);

+                    ruleSwitchStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getSwitchStatementParserRuleCall_6()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 8 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3839:6: ( ruleWhileStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3839:6: ( ruleWhileStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3840:1: ruleWhileStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getWhileStatementParserRuleCall_7()); 

+                    pushFollow(FOLLOW_ruleWhileStatement_in_rule__Statement__Alternatives8286);

+                    ruleWhileStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getWhileStatementParserRuleCall_7()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 9 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3845:6: ( ruleDoStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3845:6: ( ruleDoStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3846:1: ruleDoStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getDoStatementParserRuleCall_8()); 

+                    pushFollow(FOLLOW_ruleDoStatement_in_rule__Statement__Alternatives8303);

+                    ruleDoStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getDoStatementParserRuleCall_8()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 10 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3851:6: ( ruleForStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3851:6: ( ruleForStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3852:1: ruleForStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getForStatementParserRuleCall_9()); 

+                    pushFollow(FOLLOW_ruleForStatement_in_rule__Statement__Alternatives8320);

+                    ruleForStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getForStatementParserRuleCall_9()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 11 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3857:6: ( ruleBreakStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3857:6: ( ruleBreakStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3858:1: ruleBreakStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getBreakStatementParserRuleCall_10()); 

+                    pushFollow(FOLLOW_ruleBreakStatement_in_rule__Statement__Alternatives8337);

+                    ruleBreakStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getBreakStatementParserRuleCall_10()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 12 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3863:6: ( ruleReturnStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3863:6: ( ruleReturnStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3864:1: ruleReturnStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getReturnStatementParserRuleCall_11()); 

+                    pushFollow(FOLLOW_ruleReturnStatement_in_rule__Statement__Alternatives8354);

+                    ruleReturnStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getReturnStatementParserRuleCall_11()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 13 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3869:6: ( ruleAcceptStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3869:6: ( ruleAcceptStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3870:1: ruleAcceptStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getAcceptStatementParserRuleCall_12()); 

+                    pushFollow(FOLLOW_ruleAcceptStatement_in_rule__Statement__Alternatives8371);

+                    ruleAcceptStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getAcceptStatementParserRuleCall_12()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 14 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3875:6: ( ruleClassifyStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3875:6: ( ruleClassifyStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3876:1: ruleClassifyStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getClassifyStatementParserRuleCall_13()); 

+                    pushFollow(FOLLOW_ruleClassifyStatement_in_rule__Statement__Alternatives8388);

+                    ruleClassifyStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getClassifyStatementParserRuleCall_13()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 15 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3881:6: ( ruleInvocationOrAssignementOrDeclarationStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3881:6: ( ruleInvocationOrAssignementOrDeclarationStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3882:1: ruleInvocationOrAssignementOrDeclarationStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getInvocationOrAssignementOrDeclarationStatementParserRuleCall_14()); 

+                    pushFollow(FOLLOW_ruleInvocationOrAssignementOrDeclarationStatement_in_rule__Statement__Alternatives8405);

+                    ruleInvocationOrAssignementOrDeclarationStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getInvocationOrAssignementOrDeclarationStatementParserRuleCall_14()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 16 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3887:6: ( ruleSuperInvocationStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3887:6: ( ruleSuperInvocationStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3888:1: ruleSuperInvocationStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getSuperInvocationStatementParserRuleCall_15()); 

+                    pushFollow(FOLLOW_ruleSuperInvocationStatement_in_rule__Statement__Alternatives8422);

+                    ruleSuperInvocationStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getSuperInvocationStatementParserRuleCall_15()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 17 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3893:6: ( ruleThisInvocationStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3893:6: ( ruleThisInvocationStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3894:1: ruleThisInvocationStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getThisInvocationStatementParserRuleCall_16()); 

+                    pushFollow(FOLLOW_ruleThisInvocationStatement_in_rule__Statement__Alternatives8439);

+                    ruleThisInvocationStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getThisInvocationStatementParserRuleCall_16()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 18 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3899:6: ( ruleInstanceCreationInvocationStatement )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3899:6: ( ruleInstanceCreationInvocationStatement )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3900:1: ruleInstanceCreationInvocationStatement

+                    {

+                     before(grammarAccess.getStatementAccess().getInstanceCreationInvocationStatementParserRuleCall_17()); 

+                    pushFollow(FOLLOW_ruleInstanceCreationInvocationStatement_in_rule__Statement__Alternatives8456);

+                    ruleInstanceCreationInvocationStatement();

+

+                    state._fsp--;

+

+                     after(grammarAccess.getStatementAccess().getInstanceCreationInvocationStatementParserRuleCall_17()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Statement__Alternatives"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3910:1: rule__LoopVariableDefinition__Alternatives : ( ( ( rule__LoopVariableDefinition__Group_0__0 ) ) | ( ( rule__LoopVariableDefinition__Group_1__0 ) ) );

+    public final void rule__LoopVariableDefinition__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3914:1: ( ( ( rule__LoopVariableDefinition__Group_0__0 ) ) | ( ( rule__LoopVariableDefinition__Group_1__0 ) ) )

+            int alt30=2;

+            int LA30_0 = input.LA(1);

+

+            if ( (LA30_0==RULE_ID) ) {

+                int LA30_1 = input.LA(2);

+

+                if ( (LA30_1==106) ) {

+                    alt30=1;

+                }

+                else if ( (LA30_1==RULE_ID||LA30_1==18||LA30_1==65) ) {

+                    alt30=2;

+                }

+                else {

+                    NoViableAltException nvae =

+                        new NoViableAltException("", 30, 1, input);

+

+                    throw nvae;

+                }

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 30, 0, input);

+

+                throw nvae;

+            }

+            switch (alt30) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3915:1: ( ( rule__LoopVariableDefinition__Group_0__0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3915:1: ( ( rule__LoopVariableDefinition__Group_0__0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3916:1: ( rule__LoopVariableDefinition__Group_0__0 )

+                    {

+                     before(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3917:1: ( rule__LoopVariableDefinition__Group_0__0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3917:2: rule__LoopVariableDefinition__Group_0__0

+                    {

+                    pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_0__0_in_rule__LoopVariableDefinition__Alternatives8488);

+                    rule__LoopVariableDefinition__Group_0__0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3921:6: ( ( rule__LoopVariableDefinition__Group_1__0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3921:6: ( ( rule__LoopVariableDefinition__Group_1__0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3922:1: ( rule__LoopVariableDefinition__Group_1__0 )

+                    {

+                     before(grammarAccess.getLoopVariableDefinitionAccess().getGroup_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3923:1: ( rule__LoopVariableDefinition__Group_1__0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3923:2: rule__LoopVariableDefinition__Group_1__0

+                    {

+                    pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_1__0_in_rule__LoopVariableDefinition__Alternatives8506);

+                    rule__LoopVariableDefinition__Group_1__0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getLoopVariableDefinitionAccess().getGroup_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Alternatives"

+

+

+    // $ANTLR start "rule__AcceptStatement__Alternatives_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3932:1: rule__AcceptStatement__Alternatives_1 : ( ( ( rule__AcceptStatement__SimpleAcceptAssignment_1_0 ) ) | ( ( rule__AcceptStatement__CompoundAcceptAssignment_1_1 ) ) );

+    public final void rule__AcceptStatement__Alternatives_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3936:1: ( ( ( rule__AcceptStatement__SimpleAcceptAssignment_1_0 ) ) | ( ( rule__AcceptStatement__CompoundAcceptAssignment_1_1 ) ) )

+            int alt31=2;

+            int LA31_0 = input.LA(1);

+

+            if ( (LA31_0==95) ) {

+                alt31=1;

+            }

+            else if ( (LA31_0==87) ) {

+                alt31=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 31, 0, input);

+

+                throw nvae;

+            }

+            switch (alt31) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3937:1: ( ( rule__AcceptStatement__SimpleAcceptAssignment_1_0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3937:1: ( ( rule__AcceptStatement__SimpleAcceptAssignment_1_0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3938:1: ( rule__AcceptStatement__SimpleAcceptAssignment_1_0 )

+                    {

+                     before(grammarAccess.getAcceptStatementAccess().getSimpleAcceptAssignment_1_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3939:1: ( rule__AcceptStatement__SimpleAcceptAssignment_1_0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3939:2: rule__AcceptStatement__SimpleAcceptAssignment_1_0

+                    {

+                    pushFollow(FOLLOW_rule__AcceptStatement__SimpleAcceptAssignment_1_0_in_rule__AcceptStatement__Alternatives_18539);

+                    rule__AcceptStatement__SimpleAcceptAssignment_1_0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getAcceptStatementAccess().getSimpleAcceptAssignment_1_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3943:6: ( ( rule__AcceptStatement__CompoundAcceptAssignment_1_1 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3943:6: ( ( rule__AcceptStatement__CompoundAcceptAssignment_1_1 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3944:1: ( rule__AcceptStatement__CompoundAcceptAssignment_1_1 )

+                    {

+                     before(grammarAccess.getAcceptStatementAccess().getCompoundAcceptAssignment_1_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3945:1: ( rule__AcceptStatement__CompoundAcceptAssignment_1_1 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3945:2: rule__AcceptStatement__CompoundAcceptAssignment_1_1

+                    {

+                    pushFollow(FOLLOW_rule__AcceptStatement__CompoundAcceptAssignment_1_1_in_rule__AcceptStatement__Alternatives_18557);

+                    rule__AcceptStatement__CompoundAcceptAssignment_1_1();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getAcceptStatementAccess().getCompoundAcceptAssignment_1_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptStatement__Alternatives_1"

+

+

+    // $ANTLR start "rule__ClassificationClause__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3954:1: rule__ClassificationClause__Alternatives : ( ( ( rule__ClassificationClause__Group_0__0 ) ) | ( ( rule__ClassificationClause__Group_1__0 ) ) );

+    public final void rule__ClassificationClause__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3958:1: ( ( ( rule__ClassificationClause__Group_0__0 ) ) | ( ( rule__ClassificationClause__Group_1__0 ) ) )

+            int alt32=2;

+            int LA32_0 = input.LA(1);

+

+            if ( (LA32_0==111) ) {

+                int LA32_1 = input.LA(2);

+

+                if ( (LA32_1==27) ) {

+                    alt32=2;

+                }

+                else if ( (LA32_1==RULE_ID) ) {

+                    alt32=1;

+                }

+                else {

+                    NoViableAltException nvae =

+                        new NoViableAltException("", 32, 1, input);

+

+                    throw nvae;

+                }

+            }

+            else if ( (LA32_0==112) ) {

+                alt32=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 32, 0, input);

+

+                throw nvae;

+            }

+            switch (alt32) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3959:1: ( ( rule__ClassificationClause__Group_0__0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3959:1: ( ( rule__ClassificationClause__Group_0__0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3960:1: ( rule__ClassificationClause__Group_0__0 )

+                    {

+                     before(grammarAccess.getClassificationClauseAccess().getGroup_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3961:1: ( rule__ClassificationClause__Group_0__0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3961:2: rule__ClassificationClause__Group_0__0

+                    {

+                    pushFollow(FOLLOW_rule__ClassificationClause__Group_0__0_in_rule__ClassificationClause__Alternatives8590);

+                    rule__ClassificationClause__Group_0__0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getClassificationClauseAccess().getGroup_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3965:6: ( ( rule__ClassificationClause__Group_1__0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3965:6: ( ( rule__ClassificationClause__Group_1__0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3966:1: ( rule__ClassificationClause__Group_1__0 )

+                    {

+                     before(grammarAccess.getClassificationClauseAccess().getGroup_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3967:1: ( rule__ClassificationClause__Group_1__0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3967:2: rule__ClassificationClause__Group_1__0

+                    {

+                    pushFollow(FOLLOW_rule__ClassificationClause__Group_1__0_in_rule__ClassificationClause__Alternatives8608);

+                    rule__ClassificationClause__Group_1__0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getClassificationClauseAccess().getGroup_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationClause__Alternatives"

+

+

+    // $ANTLR start "rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3976:1: rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1 : ( ( ( rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0 ) ) | ( ( rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1 ) ) );

+    public final void rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3980:1: ( ( ( rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0 ) ) | ( ( rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1 ) ) )

+            int alt33=2;

+            int LA33_0 = input.LA(1);

+

+            if ( (LA33_0==RULE_ID||LA33_0==78) ) {

+                alt33=1;

+            }

+            else if ( ((LA33_0>=49 && LA33_0<=60)) ) {

+                alt33=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 33, 0, input);

+

+                throw nvae;

+            }

+            switch (alt33) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3981:1: ( ( rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3981:1: ( ( rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3982:1: ( rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0 )

+                    {

+                     before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionAssignment_1_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3983:1: ( rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3983:2: rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0

+                    {

+                    pushFollow(FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0_in_rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_18641);

+                    rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionAssignment_1_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3987:6: ( ( rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1 ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3987:6: ( ( rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1 ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3988:1: ( rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1 )

+                    {

+                     before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignment_1_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3989:1: ( rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1 )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3989:2: rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1

+                    {

+                    pushFollow(FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1_in_rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_18659);

+                    rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1();

+

+                    state._fsp--;

+

+

+                    }

+

+                     after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignment_1_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1"

+

+

+    // $ANTLR start "rule__BooleanValue__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:3998:1: rule__BooleanValue__Alternatives : ( ( ( 'true' ) ) | ( ( 'false' ) ) );

+    public final void rule__BooleanValue__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4002:1: ( ( ( 'true' ) ) | ( ( 'false' ) ) )

+            int alt34=2;

+            int LA34_0 = input.LA(1);

+

+            if ( (LA34_0==33) ) {

+                alt34=1;

+            }

+            else if ( (LA34_0==34) ) {

+                alt34=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 34, 0, input);

+

+                throw nvae;

+            }

+            switch (alt34) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4003:1: ( ( 'true' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4003:1: ( ( 'true' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4004:1: ( 'true' )

+                    {

+                     before(grammarAccess.getBooleanValueAccess().getTRUEEnumLiteralDeclaration_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4005:1: ( 'true' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4005:3: 'true'

+                    {

+                    match(input,33,FOLLOW_33_in_rule__BooleanValue__Alternatives8693); 

+

+                    }

+

+                     after(grammarAccess.getBooleanValueAccess().getTRUEEnumLiteralDeclaration_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4010:6: ( ( 'false' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4010:6: ( ( 'false' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4011:1: ( 'false' )

+                    {

+                     before(grammarAccess.getBooleanValueAccess().getFALSEEnumLiteralDeclaration_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4012:1: ( 'false' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4012:3: 'false'

+                    {

+                    match(input,34,FOLLOW_34_in_rule__BooleanValue__Alternatives8714); 

+

+                    }

+

+                     after(grammarAccess.getBooleanValueAccess().getFALSEEnumLiteralDeclaration_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__BooleanValue__Alternatives"

+

+

+    // $ANTLR start "rule__LinkOperationKind__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4022:1: rule__LinkOperationKind__Alternatives : ( ( ( 'createLink' ) ) | ( ( 'destroyLink' ) ) | ( ( 'clearAssoc' ) ) );

+    public final void rule__LinkOperationKind__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4026:1: ( ( ( 'createLink' ) ) | ( ( 'destroyLink' ) ) | ( ( 'clearAssoc' ) ) )

+            int alt35=3;

+            switch ( input.LA(1) ) {

+            case 35:

+                {

+                alt35=1;

+                }

+                break;

+            case 36:

+                {

+                alt35=2;

+                }

+                break;

+            case 37:

+                {

+                alt35=3;

+                }

+                break;

+            default:

+                NoViableAltException nvae =

+                    new NoViableAltException("", 35, 0, input);

+

+                throw nvae;

+            }

+

+            switch (alt35) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4027:1: ( ( 'createLink' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4027:1: ( ( 'createLink' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4028:1: ( 'createLink' )

+                    {

+                     before(grammarAccess.getLinkOperationKindAccess().getCREATEEnumLiteralDeclaration_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4029:1: ( 'createLink' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4029:3: 'createLink'

+                    {

+                    match(input,35,FOLLOW_35_in_rule__LinkOperationKind__Alternatives8750); 

+

+                    }

+

+                     after(grammarAccess.getLinkOperationKindAccess().getCREATEEnumLiteralDeclaration_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4034:6: ( ( 'destroyLink' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4034:6: ( ( 'destroyLink' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4035:1: ( 'destroyLink' )

+                    {

+                     before(grammarAccess.getLinkOperationKindAccess().getDESTROYEnumLiteralDeclaration_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4036:1: ( 'destroyLink' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4036:3: 'destroyLink'

+                    {

+                    match(input,36,FOLLOW_36_in_rule__LinkOperationKind__Alternatives8771); 

+

+                    }

+

+                     after(grammarAccess.getLinkOperationKindAccess().getDESTROYEnumLiteralDeclaration_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4041:6: ( ( 'clearAssoc' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4041:6: ( ( 'clearAssoc' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4042:1: ( 'clearAssoc' )

+                    {

+                     before(grammarAccess.getLinkOperationKindAccess().getCLEAREnumLiteralDeclaration_2()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4043:1: ( 'clearAssoc' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4043:3: 'clearAssoc'

+                    {

+                    match(input,37,FOLLOW_37_in_rule__LinkOperationKind__Alternatives8792); 

+

+                    }

+

+                     after(grammarAccess.getLinkOperationKindAccess().getCLEAREnumLiteralDeclaration_2()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationKind__Alternatives"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperator__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4053:1: rule__SelectOrRejectOperator__Alternatives : ( ( ( 'select' ) ) | ( ( 'reject' ) ) );

+    public final void rule__SelectOrRejectOperator__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4057:1: ( ( ( 'select' ) ) | ( ( 'reject' ) ) )

+            int alt36=2;

+            int LA36_0 = input.LA(1);

+

+            if ( (LA36_0==38) ) {

+                alt36=1;

+            }

+            else if ( (LA36_0==39) ) {

+                alt36=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 36, 0, input);

+

+                throw nvae;

+            }

+            switch (alt36) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4058:1: ( ( 'select' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4058:1: ( ( 'select' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4059:1: ( 'select' )

+                    {

+                     before(grammarAccess.getSelectOrRejectOperatorAccess().getSELECTEnumLiteralDeclaration_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4060:1: ( 'select' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4060:3: 'select'

+                    {

+                    match(input,38,FOLLOW_38_in_rule__SelectOrRejectOperator__Alternatives8828); 

+

+                    }

+

+                     after(grammarAccess.getSelectOrRejectOperatorAccess().getSELECTEnumLiteralDeclaration_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4065:6: ( ( 'reject' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4065:6: ( ( 'reject' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4066:1: ( 'reject' )

+                    {

+                     before(grammarAccess.getSelectOrRejectOperatorAccess().getREJECTEnumLiteralDeclaration_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4067:1: ( 'reject' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4067:3: 'reject'

+                    {

+                    match(input,39,FOLLOW_39_in_rule__SelectOrRejectOperator__Alternatives8849); 

+

+                    }

+

+                     after(grammarAccess.getSelectOrRejectOperatorAccess().getREJECTEnumLiteralDeclaration_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperator__Alternatives"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperator__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4077:1: rule__CollectOrIterateOperator__Alternatives : ( ( ( 'collect' ) ) | ( ( 'iterate' ) ) );

+    public final void rule__CollectOrIterateOperator__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4081:1: ( ( ( 'collect' ) ) | ( ( 'iterate' ) ) )

+            int alt37=2;

+            int LA37_0 = input.LA(1);

+

+            if ( (LA37_0==40) ) {

+                alt37=1;

+            }

+            else if ( (LA37_0==41) ) {

+                alt37=2;

+            }

+            else {

+                NoViableAltException nvae =

+                    new NoViableAltException("", 37, 0, input);

+

+                throw nvae;

+            }

+            switch (alt37) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4082:1: ( ( 'collect' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4082:1: ( ( 'collect' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4083:1: ( 'collect' )

+                    {

+                     before(grammarAccess.getCollectOrIterateOperatorAccess().getCOLLECTEnumLiteralDeclaration_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4084:1: ( 'collect' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4084:3: 'collect'

+                    {

+                    match(input,40,FOLLOW_40_in_rule__CollectOrIterateOperator__Alternatives8885); 

+

+                    }

+

+                     after(grammarAccess.getCollectOrIterateOperatorAccess().getCOLLECTEnumLiteralDeclaration_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4089:6: ( ( 'iterate' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4089:6: ( ( 'iterate' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4090:1: ( 'iterate' )

+                    {

+                     before(grammarAccess.getCollectOrIterateOperatorAccess().getITERATEEnumLiteralDeclaration_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4091:1: ( 'iterate' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4091:3: 'iterate'

+                    {

+                    match(input,41,FOLLOW_41_in_rule__CollectOrIterateOperator__Alternatives8906); 

+

+                    }

+

+                     after(grammarAccess.getCollectOrIterateOperatorAccess().getITERATEEnumLiteralDeclaration_1()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperator__Alternatives"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperator__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4101:1: rule__ForAllOrExistsOrOneOperator__Alternatives : ( ( ( 'forAll' ) ) | ( ( 'exists' ) ) | ( ( 'one' ) ) );

+    public final void rule__ForAllOrExistsOrOneOperator__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4105:1: ( ( ( 'forAll' ) ) | ( ( 'exists' ) ) | ( ( 'one' ) ) )

+            int alt38=3;

+            switch ( input.LA(1) ) {

+            case 42:

+                {

+                alt38=1;

+                }

+                break;

+            case 43:

+                {

+                alt38=2;

+                }

+                break;

+            case 44:

+                {

+                alt38=3;

+                }

+                break;

+            default:

+                NoViableAltException nvae =

+                    new NoViableAltException("", 38, 0, input);

+

+                throw nvae;

+            }

+

+            switch (alt38) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4106:1: ( ( 'forAll' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4106:1: ( ( 'forAll' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4107:1: ( 'forAll' )

+                    {

+                     before(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getFORALLEnumLiteralDeclaration_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4108:1: ( 'forAll' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4108:3: 'forAll'

+                    {

+                    match(input,42,FOLLOW_42_in_rule__ForAllOrExistsOrOneOperator__Alternatives8942); 

+

+                    }

+

+                     after(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getFORALLEnumLiteralDeclaration_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4113:6: ( ( 'exists' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4113:6: ( ( 'exists' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4114:1: ( 'exists' )

+                    {

+                     before(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getEXISTSEnumLiteralDeclaration_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4115:1: ( 'exists' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4115:3: 'exists'

+                    {

+                    match(input,43,FOLLOW_43_in_rule__ForAllOrExistsOrOneOperator__Alternatives8963); 

+

+                    }

+

+                     after(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getEXISTSEnumLiteralDeclaration_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4120:6: ( ( 'one' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4120:6: ( ( 'one' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4121:1: ( 'one' )

+                    {

+                     before(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getONEEnumLiteralDeclaration_2()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4122:1: ( 'one' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4122:3: 'one'

+                    {

+                    match(input,44,FOLLOW_44_in_rule__ForAllOrExistsOrOneOperator__Alternatives8984); 

+

+                    }

+

+                     after(grammarAccess.getForAllOrExistsOrOneOperatorAccess().getONEEnumLiteralDeclaration_2()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperator__Alternatives"

+

+

+    // $ANTLR start "rule__AnnotationKind__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4132:1: rule__AnnotationKind__Alternatives : ( ( ( 'isolated' ) ) | ( ( 'determined' ) ) | ( ( 'assured' ) ) | ( ( 'parallel' ) ) );

+    public final void rule__AnnotationKind__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4136:1: ( ( ( 'isolated' ) ) | ( ( 'determined' ) ) | ( ( 'assured' ) ) | ( ( 'parallel' ) ) )

+            int alt39=4;

+            switch ( input.LA(1) ) {

+            case 45:

+                {

+                alt39=1;

+                }

+                break;

+            case 46:

+                {

+                alt39=2;

+                }

+                break;

+            case 47:

+                {

+                alt39=3;

+                }

+                break;

+            case 48:

+                {

+                alt39=4;

+                }

+                break;

+            default:

+                NoViableAltException nvae =

+                    new NoViableAltException("", 39, 0, input);

+

+                throw nvae;

+            }

+

+            switch (alt39) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4137:1: ( ( 'isolated' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4137:1: ( ( 'isolated' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4138:1: ( 'isolated' )

+                    {

+                     before(grammarAccess.getAnnotationKindAccess().getISOLATEDEnumLiteralDeclaration_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4139:1: ( 'isolated' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4139:3: 'isolated'

+                    {

+                    match(input,45,FOLLOW_45_in_rule__AnnotationKind__Alternatives9020); 

+

+                    }

+

+                     after(grammarAccess.getAnnotationKindAccess().getISOLATEDEnumLiteralDeclaration_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4144:6: ( ( 'determined' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4144:6: ( ( 'determined' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4145:1: ( 'determined' )

+                    {

+                     before(grammarAccess.getAnnotationKindAccess().getDETERMINEDEnumLiteralDeclaration_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4146:1: ( 'determined' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4146:3: 'determined'

+                    {

+                    match(input,46,FOLLOW_46_in_rule__AnnotationKind__Alternatives9041); 

+

+                    }

+

+                     after(grammarAccess.getAnnotationKindAccess().getDETERMINEDEnumLiteralDeclaration_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4151:6: ( ( 'assured' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4151:6: ( ( 'assured' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4152:1: ( 'assured' )

+                    {

+                     before(grammarAccess.getAnnotationKindAccess().getASSUREDEnumLiteralDeclaration_2()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4153:1: ( 'assured' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4153:3: 'assured'

+                    {

+                    match(input,47,FOLLOW_47_in_rule__AnnotationKind__Alternatives9062); 

+

+                    }

+

+                     after(grammarAccess.getAnnotationKindAccess().getASSUREDEnumLiteralDeclaration_2()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 4 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4158:6: ( ( 'parallel' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4158:6: ( ( 'parallel' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4159:1: ( 'parallel' )

+                    {

+                     before(grammarAccess.getAnnotationKindAccess().getPARALLELEnumLiteralDeclaration_3()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4160:1: ( 'parallel' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4160:3: 'parallel'

+                    {

+                    match(input,48,FOLLOW_48_in_rule__AnnotationKind__Alternatives9083); 

+

+                    }

+

+                     after(grammarAccess.getAnnotationKindAccess().getPARALLELEnumLiteralDeclaration_3()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AnnotationKind__Alternatives"

+

+

+    // $ANTLR start "rule__AssignmentOperator__Alternatives"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4170:1: rule__AssignmentOperator__Alternatives : ( ( ( '=' ) ) | ( ( '+=' ) ) | ( ( '-=' ) ) | ( ( '*=' ) ) | ( ( '%=' ) ) | ( ( '/=' ) ) | ( ( '&=' ) ) | ( ( '|=' ) ) | ( ( '^=' ) ) | ( ( '<<=' ) ) | ( ( '>>=' ) ) | ( ( '>>>=' ) ) );

+    public final void rule__AssignmentOperator__Alternatives() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4174:1: ( ( ( '=' ) ) | ( ( '+=' ) ) | ( ( '-=' ) ) | ( ( '*=' ) ) | ( ( '%=' ) ) | ( ( '/=' ) ) | ( ( '&=' ) ) | ( ( '|=' ) ) | ( ( '^=' ) ) | ( ( '<<=' ) ) | ( ( '>>=' ) ) | ( ( '>>>=' ) ) )

+            int alt40=12;

+            switch ( input.LA(1) ) {

+            case 49:

+                {

+                alt40=1;

+                }

+                break;

+            case 50:

+                {

+                alt40=2;

+                }

+                break;

+            case 51:

+                {

+                alt40=3;

+                }

+                break;

+            case 52:

+                {

+                alt40=4;

+                }

+                break;

+            case 53:

+                {

+                alt40=5;

+                }

+                break;

+            case 54:

+                {

+                alt40=6;

+                }

+                break;

+            case 55:

+                {

+                alt40=7;

+                }

+                break;

+            case 56:

+                {

+                alt40=8;

+                }

+                break;

+            case 57:

+                {

+                alt40=9;

+                }

+                break;

+            case 58:

+                {

+                alt40=10;

+                }

+                break;

+            case 59:

+                {

+                alt40=11;

+                }

+                break;

+            case 60:

+                {

+                alt40=12;

+                }

+                break;

+            default:

+                NoViableAltException nvae =

+                    new NoViableAltException("", 40, 0, input);

+

+                throw nvae;

+            }

+

+            switch (alt40) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4175:1: ( ( '=' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4175:1: ( ( '=' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4176:1: ( '=' )

+                    {

+                     before(grammarAccess.getAssignmentOperatorAccess().getASSIGNEnumLiteralDeclaration_0()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4177:1: ( '=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4177:3: '='

+                    {

+                    match(input,49,FOLLOW_49_in_rule__AssignmentOperator__Alternatives9119); 

+

+                    }

+

+                     after(grammarAccess.getAssignmentOperatorAccess().getASSIGNEnumLiteralDeclaration_0()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 2 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4182:6: ( ( '+=' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4182:6: ( ( '+=' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4183:1: ( '+=' )

+                    {

+                     before(grammarAccess.getAssignmentOperatorAccess().getPLUSASSIGNEnumLiteralDeclaration_1()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4184:1: ( '+=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4184:3: '+='

+                    {

+                    match(input,50,FOLLOW_50_in_rule__AssignmentOperator__Alternatives9140); 

+

+                    }

+

+                     after(grammarAccess.getAssignmentOperatorAccess().getPLUSASSIGNEnumLiteralDeclaration_1()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 3 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4189:6: ( ( '-=' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4189:6: ( ( '-=' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4190:1: ( '-=' )

+                    {

+                     before(grammarAccess.getAssignmentOperatorAccess().getMINUSASSIGNEnumLiteralDeclaration_2()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4191:1: ( '-=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4191:3: '-='

+                    {

+                    match(input,51,FOLLOW_51_in_rule__AssignmentOperator__Alternatives9161); 

+

+                    }

+

+                     after(grammarAccess.getAssignmentOperatorAccess().getMINUSASSIGNEnumLiteralDeclaration_2()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 4 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4196:6: ( ( '*=' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4196:6: ( ( '*=' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4197:1: ( '*=' )

+                    {

+                     before(grammarAccess.getAssignmentOperatorAccess().getMULTASSIGNEnumLiteralDeclaration_3()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4198:1: ( '*=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4198:3: '*='

+                    {

+                    match(input,52,FOLLOW_52_in_rule__AssignmentOperator__Alternatives9182); 

+

+                    }

+

+                     after(grammarAccess.getAssignmentOperatorAccess().getMULTASSIGNEnumLiteralDeclaration_3()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 5 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4203:6: ( ( '%=' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4203:6: ( ( '%=' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4204:1: ( '%=' )

+                    {

+                     before(grammarAccess.getAssignmentOperatorAccess().getMODASSIGNEnumLiteralDeclaration_4()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4205:1: ( '%=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4205:3: '%='

+                    {

+                    match(input,53,FOLLOW_53_in_rule__AssignmentOperator__Alternatives9203); 

+

+                    }

+

+                     after(grammarAccess.getAssignmentOperatorAccess().getMODASSIGNEnumLiteralDeclaration_4()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 6 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4210:6: ( ( '/=' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4210:6: ( ( '/=' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4211:1: ( '/=' )

+                    {

+                     before(grammarAccess.getAssignmentOperatorAccess().getDIVASSIGNEnumLiteralDeclaration_5()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4212:1: ( '/=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4212:3: '/='

+                    {

+                    match(input,54,FOLLOW_54_in_rule__AssignmentOperator__Alternatives9224); 

+

+                    }

+

+                     after(grammarAccess.getAssignmentOperatorAccess().getDIVASSIGNEnumLiteralDeclaration_5()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 7 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4217:6: ( ( '&=' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4217:6: ( ( '&=' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4218:1: ( '&=' )

+                    {

+                     before(grammarAccess.getAssignmentOperatorAccess().getANDASSIGNEnumLiteralDeclaration_6()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4219:1: ( '&=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4219:3: '&='

+                    {

+                    match(input,55,FOLLOW_55_in_rule__AssignmentOperator__Alternatives9245); 

+

+                    }

+

+                     after(grammarAccess.getAssignmentOperatorAccess().getANDASSIGNEnumLiteralDeclaration_6()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 8 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4224:6: ( ( '|=' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4224:6: ( ( '|=' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4225:1: ( '|=' )

+                    {

+                     before(grammarAccess.getAssignmentOperatorAccess().getORASSIGNEnumLiteralDeclaration_7()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4226:1: ( '|=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4226:3: '|='

+                    {

+                    match(input,56,FOLLOW_56_in_rule__AssignmentOperator__Alternatives9266); 

+

+                    }

+

+                     after(grammarAccess.getAssignmentOperatorAccess().getORASSIGNEnumLiteralDeclaration_7()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 9 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4231:6: ( ( '^=' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4231:6: ( ( '^=' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4232:1: ( '^=' )

+                    {

+                     before(grammarAccess.getAssignmentOperatorAccess().getXORASSIGNEnumLiteralDeclaration_8()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4233:1: ( '^=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4233:3: '^='

+                    {

+                    match(input,57,FOLLOW_57_in_rule__AssignmentOperator__Alternatives9287); 

+

+                    }

+

+                     after(grammarAccess.getAssignmentOperatorAccess().getXORASSIGNEnumLiteralDeclaration_8()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 10 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4238:6: ( ( '<<=' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4238:6: ( ( '<<=' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4239:1: ( '<<=' )

+                    {

+                     before(grammarAccess.getAssignmentOperatorAccess().getLSHIFTASSIGNEnumLiteralDeclaration_9()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4240:1: ( '<<=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4240:3: '<<='

+                    {

+                    match(input,58,FOLLOW_58_in_rule__AssignmentOperator__Alternatives9308); 

+

+                    }

+

+                     after(grammarAccess.getAssignmentOperatorAccess().getLSHIFTASSIGNEnumLiteralDeclaration_9()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 11 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4245:6: ( ( '>>=' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4245:6: ( ( '>>=' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4246:1: ( '>>=' )

+                    {

+                     before(grammarAccess.getAssignmentOperatorAccess().getRSHIFTASSIGNEnumLiteralDeclaration_10()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4247:1: ( '>>=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4247:3: '>>='

+                    {

+                    match(input,59,FOLLOW_59_in_rule__AssignmentOperator__Alternatives9329); 

+

+                    }

+

+                     after(grammarAccess.getAssignmentOperatorAccess().getRSHIFTASSIGNEnumLiteralDeclaration_10()); 

+

+                    }

+

+

+                    }

+                    break;

+                case 12 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4252:6: ( ( '>>>=' ) )

+                    {

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4252:6: ( ( '>>>=' ) )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4253:1: ( '>>>=' )

+                    {

+                     before(grammarAccess.getAssignmentOperatorAccess().getURSHIFTASSIGNEnumLiteralDeclaration_11()); 

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4254:1: ( '>>>=' )

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4254:3: '>>>='

+                    {

+                    match(input,60,FOLLOW_60_in_rule__AssignmentOperator__Alternatives9350); 

+

+                    }

+

+                     after(grammarAccess.getAssignmentOperatorAccess().getURSHIFTASSIGNEnumLiteralDeclaration_11()); 

+

+                    }

+

+

+                    }

+                    break;

+

+            }

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AssignmentOperator__Alternatives"

+

+

+    // $ANTLR start "rule__Test__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4266:1: rule__Test__Group__0 : rule__Test__Group__0__Impl rule__Test__Group__1 ;

+    public final void rule__Test__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4270:1: ( rule__Test__Group__0__Impl rule__Test__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4271:2: rule__Test__Group__0__Impl rule__Test__Group__1

+            {

+            pushFollow(FOLLOW_rule__Test__Group__0__Impl_in_rule__Test__Group__09383);

+            rule__Test__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Test__Group__1_in_rule__Test__Group__09386);

+            rule__Test__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group__0"

+

+

+    // $ANTLR start "rule__Test__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4278:1: rule__Test__Group__0__Impl : ( ( rule__Test__Group_0__0 )* ) ;

+    public final void rule__Test__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4282:1: ( ( ( rule__Test__Group_0__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4283:1: ( ( rule__Test__Group_0__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4283:1: ( ( rule__Test__Group_0__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4284:1: ( rule__Test__Group_0__0 )*

+            {

+             before(grammarAccess.getTestAccess().getGroup_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4285:1: ( rule__Test__Group_0__0 )*

+            loop41:

+            do {

+                int alt41=2;

+                int LA41_0 = input.LA(1);

+

+                if ( (LA41_0==61) ) {

+                    alt41=1;

+                }

+

+

+                switch (alt41) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4285:2: rule__Test__Group_0__0

+            	    {

+            	    pushFollow(FOLLOW_rule__Test__Group_0__0_in_rule__Test__Group__0__Impl9413);

+            	    rule__Test__Group_0__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop41;

+                }

+            } while (true);

+

+             after(grammarAccess.getTestAccess().getGroup_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group__0__Impl"

+

+

+    // $ANTLR start "rule__Test__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4295:1: rule__Test__Group__1 : rule__Test__Group__1__Impl rule__Test__Group__2 ;

+    public final void rule__Test__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4299:1: ( rule__Test__Group__1__Impl rule__Test__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4300:2: rule__Test__Group__1__Impl rule__Test__Group__2

+            {

+            pushFollow(FOLLOW_rule__Test__Group__1__Impl_in_rule__Test__Group__19444);

+            rule__Test__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Test__Group__2_in_rule__Test__Group__19447);

+            rule__Test__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group__1"

+

+

+    // $ANTLR start "rule__Test__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4307:1: rule__Test__Group__1__Impl : ( ( rule__Test__Group_1__0 )* ) ;

+    public final void rule__Test__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4311:1: ( ( ( rule__Test__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4312:1: ( ( rule__Test__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4312:1: ( ( rule__Test__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4313:1: ( rule__Test__Group_1__0 )*

+            {

+             before(grammarAccess.getTestAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4314:1: ( rule__Test__Group_1__0 )*

+            loop42:

+            do {

+                int alt42=2;

+                int LA42_0 = input.LA(1);

+

+                if ( (LA42_0==62) ) {

+                    alt42=1;

+                }

+

+

+                switch (alt42) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4314:2: rule__Test__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__Test__Group_1__0_in_rule__Test__Group__1__Impl9474);

+            	    rule__Test__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop42;

+                }

+            } while (true);

+

+             after(grammarAccess.getTestAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group__1__Impl"

+

+

+    // $ANTLR start "rule__Test__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4324:1: rule__Test__Group__2 : rule__Test__Group__2__Impl rule__Test__Group__3 ;

+    public final void rule__Test__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4328:1: ( rule__Test__Group__2__Impl rule__Test__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4329:2: rule__Test__Group__2__Impl rule__Test__Group__3

+            {

+            pushFollow(FOLLOW_rule__Test__Group__2__Impl_in_rule__Test__Group__29505);

+            rule__Test__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Test__Group__3_in_rule__Test__Group__29508);

+            rule__Test__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group__2"

+

+

+    // $ANTLR start "rule__Test__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4336:1: rule__Test__Group__2__Impl : ( ( rule__Test__Group_2__0 )* ) ;

+    public final void rule__Test__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4340:1: ( ( ( rule__Test__Group_2__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4341:1: ( ( rule__Test__Group_2__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4341:1: ( ( rule__Test__Group_2__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4342:1: ( rule__Test__Group_2__0 )*

+            {

+             before(grammarAccess.getTestAccess().getGroup_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4343:1: ( rule__Test__Group_2__0 )*

+            loop43:

+            do {

+                int alt43=2;

+                int LA43_0 = input.LA(1);

+

+                if ( (LA43_0==63) ) {

+                    alt43=1;

+                }

+

+

+                switch (alt43) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4343:2: rule__Test__Group_2__0

+            	    {

+            	    pushFollow(FOLLOW_rule__Test__Group_2__0_in_rule__Test__Group__2__Impl9535);

+            	    rule__Test__Group_2__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop43;

+                }

+            } while (true);

+

+             after(grammarAccess.getTestAccess().getGroup_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group__2__Impl"

+

+

+    // $ANTLR start "rule__Test__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4353:1: rule__Test__Group__3 : rule__Test__Group__3__Impl ;

+    public final void rule__Test__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4357:1: ( rule__Test__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4358:2: rule__Test__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__Test__Group__3__Impl_in_rule__Test__Group__39566);

+            rule__Test__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group__3"

+

+

+    // $ANTLR start "rule__Test__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4364:1: rule__Test__Group__3__Impl : ( ( rule__Test__Group_3__0 ) ) ;

+    public final void rule__Test__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4368:1: ( ( ( rule__Test__Group_3__0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4369:1: ( ( rule__Test__Group_3__0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4369:1: ( ( rule__Test__Group_3__0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4370:1: ( rule__Test__Group_3__0 )

+            {

+             before(grammarAccess.getTestAccess().getGroup_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4371:1: ( rule__Test__Group_3__0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4371:2: rule__Test__Group_3__0

+            {

+            pushFollow(FOLLOW_rule__Test__Group_3__0_in_rule__Test__Group__3__Impl9593);

+            rule__Test__Group_3__0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getTestAccess().getGroup_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group__3__Impl"

+

+

+    // $ANTLR start "rule__Test__Group_0__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4389:1: rule__Test__Group_0__0 : rule__Test__Group_0__0__Impl rule__Test__Group_0__1 ;

+    public final void rule__Test__Group_0__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4393:1: ( rule__Test__Group_0__0__Impl rule__Test__Group_0__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4394:2: rule__Test__Group_0__0__Impl rule__Test__Group_0__1

+            {

+            pushFollow(FOLLOW_rule__Test__Group_0__0__Impl_in_rule__Test__Group_0__09631);

+            rule__Test__Group_0__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Test__Group_0__1_in_rule__Test__Group_0__09634);

+            rule__Test__Group_0__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_0__0"

+

+

+    // $ANTLR start "rule__Test__Group_0__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4401:1: rule__Test__Group_0__0__Impl : ( 'testExpression' ) ;

+    public final void rule__Test__Group_0__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4405:1: ( ( 'testExpression' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4406:1: ( 'testExpression' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4406:1: ( 'testExpression' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4407:1: 'testExpression'

+            {

+             before(grammarAccess.getTestAccess().getTestExpressionKeyword_0_0()); 

+            match(input,61,FOLLOW_61_in_rule__Test__Group_0__0__Impl9662); 

+             after(grammarAccess.getTestAccess().getTestExpressionKeyword_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_0__0__Impl"

+

+

+    // $ANTLR start "rule__Test__Group_0__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4420:1: rule__Test__Group_0__1 : rule__Test__Group_0__1__Impl ;

+    public final void rule__Test__Group_0__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4424:1: ( rule__Test__Group_0__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4425:2: rule__Test__Group_0__1__Impl

+            {

+            pushFollow(FOLLOW_rule__Test__Group_0__1__Impl_in_rule__Test__Group_0__19693);

+            rule__Test__Group_0__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_0__1"

+

+

+    // $ANTLR start "rule__Test__Group_0__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4431:1: rule__Test__Group_0__1__Impl : ( ( rule__Test__ExpressionAssignment_0_1 ) ) ;

+    public final void rule__Test__Group_0__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4435:1: ( ( ( rule__Test__ExpressionAssignment_0_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4436:1: ( ( rule__Test__ExpressionAssignment_0_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4436:1: ( ( rule__Test__ExpressionAssignment_0_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4437:1: ( rule__Test__ExpressionAssignment_0_1 )

+            {

+             before(grammarAccess.getTestAccess().getExpressionAssignment_0_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4438:1: ( rule__Test__ExpressionAssignment_0_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4438:2: rule__Test__ExpressionAssignment_0_1

+            {

+            pushFollow(FOLLOW_rule__Test__ExpressionAssignment_0_1_in_rule__Test__Group_0__1__Impl9720);

+            rule__Test__ExpressionAssignment_0_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getTestAccess().getExpressionAssignment_0_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_0__1__Impl"

+

+

+    // $ANTLR start "rule__Test__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4452:1: rule__Test__Group_1__0 : rule__Test__Group_1__0__Impl rule__Test__Group_1__1 ;

+    public final void rule__Test__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4456:1: ( rule__Test__Group_1__0__Impl rule__Test__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4457:2: rule__Test__Group_1__0__Impl rule__Test__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__Test__Group_1__0__Impl_in_rule__Test__Group_1__09754);

+            rule__Test__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Test__Group_1__1_in_rule__Test__Group_1__09757);

+            rule__Test__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_1__0"

+

+

+    // $ANTLR start "rule__Test__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4464:1: rule__Test__Group_1__0__Impl : ( 'testAssignmentExpression' ) ;

+    public final void rule__Test__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4468:1: ( ( 'testAssignmentExpression' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4469:1: ( 'testAssignmentExpression' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4469:1: ( 'testAssignmentExpression' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4470:1: 'testAssignmentExpression'

+            {

+             before(grammarAccess.getTestAccess().getTestAssignmentExpressionKeyword_1_0()); 

+            match(input,62,FOLLOW_62_in_rule__Test__Group_1__0__Impl9785); 

+             after(grammarAccess.getTestAccess().getTestAssignmentExpressionKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__Test__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4483:1: rule__Test__Group_1__1 : rule__Test__Group_1__1__Impl ;

+    public final void rule__Test__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4487:1: ( rule__Test__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4488:2: rule__Test__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__Test__Group_1__1__Impl_in_rule__Test__Group_1__19816);

+            rule__Test__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_1__1"

+

+

+    // $ANTLR start "rule__Test__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4494:1: rule__Test__Group_1__1__Impl : ( ( rule__Test__AssignExpressionAssignment_1_1 ) ) ;

+    public final void rule__Test__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4498:1: ( ( ( rule__Test__AssignExpressionAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4499:1: ( ( rule__Test__AssignExpressionAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4499:1: ( ( rule__Test__AssignExpressionAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4500:1: ( rule__Test__AssignExpressionAssignment_1_1 )

+            {

+             before(grammarAccess.getTestAccess().getAssignExpressionAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4501:1: ( rule__Test__AssignExpressionAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4501:2: rule__Test__AssignExpressionAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__Test__AssignExpressionAssignment_1_1_in_rule__Test__Group_1__1__Impl9843);

+            rule__Test__AssignExpressionAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getTestAccess().getAssignExpressionAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__Test__Group_2__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4515:1: rule__Test__Group_2__0 : rule__Test__Group_2__0__Impl rule__Test__Group_2__1 ;

+    public final void rule__Test__Group_2__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4519:1: ( rule__Test__Group_2__0__Impl rule__Test__Group_2__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4520:2: rule__Test__Group_2__0__Impl rule__Test__Group_2__1

+            {

+            pushFollow(FOLLOW_rule__Test__Group_2__0__Impl_in_rule__Test__Group_2__09877);

+            rule__Test__Group_2__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Test__Group_2__1_in_rule__Test__Group_2__09880);

+            rule__Test__Group_2__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_2__0"

+

+

+    // $ANTLR start "rule__Test__Group_2__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4527:1: rule__Test__Group_2__0__Impl : ( 'testStatement' ) ;

+    public final void rule__Test__Group_2__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4531:1: ( ( 'testStatement' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4532:1: ( 'testStatement' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4532:1: ( 'testStatement' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4533:1: 'testStatement'

+            {

+             before(grammarAccess.getTestAccess().getTestStatementKeyword_2_0()); 

+            match(input,63,FOLLOW_63_in_rule__Test__Group_2__0__Impl9908); 

+             after(grammarAccess.getTestAccess().getTestStatementKeyword_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_2__0__Impl"

+

+

+    // $ANTLR start "rule__Test__Group_2__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4546:1: rule__Test__Group_2__1 : rule__Test__Group_2__1__Impl ;

+    public final void rule__Test__Group_2__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4550:1: ( rule__Test__Group_2__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4551:2: rule__Test__Group_2__1__Impl

+            {

+            pushFollow(FOLLOW_rule__Test__Group_2__1__Impl_in_rule__Test__Group_2__19939);

+            rule__Test__Group_2__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_2__1"

+

+

+    // $ANTLR start "rule__Test__Group_2__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4557:1: rule__Test__Group_2__1__Impl : ( ( rule__Test__StatementsAssignment_2_1 ) ) ;

+    public final void rule__Test__Group_2__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4561:1: ( ( ( rule__Test__StatementsAssignment_2_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4562:1: ( ( rule__Test__StatementsAssignment_2_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4562:1: ( ( rule__Test__StatementsAssignment_2_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4563:1: ( rule__Test__StatementsAssignment_2_1 )

+            {

+             before(grammarAccess.getTestAccess().getStatementsAssignment_2_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4564:1: ( rule__Test__StatementsAssignment_2_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4564:2: rule__Test__StatementsAssignment_2_1

+            {

+            pushFollow(FOLLOW_rule__Test__StatementsAssignment_2_1_in_rule__Test__Group_2__1__Impl9966);

+            rule__Test__StatementsAssignment_2_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getTestAccess().getStatementsAssignment_2_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_2__1__Impl"

+

+

+    // $ANTLR start "rule__Test__Group_3__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4578:1: rule__Test__Group_3__0 : rule__Test__Group_3__0__Impl rule__Test__Group_3__1 ;

+    public final void rule__Test__Group_3__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4582:1: ( rule__Test__Group_3__0__Impl rule__Test__Group_3__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4583:2: rule__Test__Group_3__0__Impl rule__Test__Group_3__1

+            {

+            pushFollow(FOLLOW_rule__Test__Group_3__0__Impl_in_rule__Test__Group_3__010000);

+            rule__Test__Group_3__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Test__Group_3__1_in_rule__Test__Group_3__010003);

+            rule__Test__Group_3__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_3__0"

+

+

+    // $ANTLR start "rule__Test__Group_3__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4590:1: rule__Test__Group_3__0__Impl : ( 'testBlock' ) ;

+    public final void rule__Test__Group_3__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4594:1: ( ( 'testBlock' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4595:1: ( 'testBlock' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4595:1: ( 'testBlock' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4596:1: 'testBlock'

+            {

+             before(grammarAccess.getTestAccess().getTestBlockKeyword_3_0()); 

+            match(input,64,FOLLOW_64_in_rule__Test__Group_3__0__Impl10031); 

+             after(grammarAccess.getTestAccess().getTestBlockKeyword_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_3__0__Impl"

+

+

+    // $ANTLR start "rule__Test__Group_3__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4609:1: rule__Test__Group_3__1 : rule__Test__Group_3__1__Impl ;

+    public final void rule__Test__Group_3__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4613:1: ( rule__Test__Group_3__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4614:2: rule__Test__Group_3__1__Impl

+            {

+            pushFollow(FOLLOW_rule__Test__Group_3__1__Impl_in_rule__Test__Group_3__110062);

+            rule__Test__Group_3__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_3__1"

+

+

+    // $ANTLR start "rule__Test__Group_3__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4620:1: rule__Test__Group_3__1__Impl : ( ( rule__Test__BlockAssignment_3_1 ) ) ;

+    public final void rule__Test__Group_3__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4624:1: ( ( ( rule__Test__BlockAssignment_3_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4625:1: ( ( rule__Test__BlockAssignment_3_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4625:1: ( ( rule__Test__BlockAssignment_3_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4626:1: ( rule__Test__BlockAssignment_3_1 )

+            {

+             before(grammarAccess.getTestAccess().getBlockAssignment_3_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4627:1: ( rule__Test__BlockAssignment_3_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4627:2: rule__Test__BlockAssignment_3_1

+            {

+            pushFollow(FOLLOW_rule__Test__BlockAssignment_3_1_in_rule__Test__Group_3__1__Impl10089);

+            rule__Test__BlockAssignment_3_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getTestAccess().getBlockAssignment_3_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__Group_3__1__Impl"

+

+

+    // $ANTLR start "rule__NameExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4641:1: rule__NameExpression__Group__0 : rule__NameExpression__Group__0__Impl rule__NameExpression__Group__1 ;

+    public final void rule__NameExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4645:1: ( rule__NameExpression__Group__0__Impl rule__NameExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4646:2: rule__NameExpression__Group__0__Impl rule__NameExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__NameExpression__Group__0__Impl_in_rule__NameExpression__Group__010123);

+            rule__NameExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__NameExpression__Group__1_in_rule__NameExpression__Group__010126);

+            rule__NameExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group__0"

+

+

+    // $ANTLR start "rule__NameExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4653:1: rule__NameExpression__Group__0__Impl : ( ( rule__NameExpression__Alternatives_0 ) ) ;

+    public final void rule__NameExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4657:1: ( ( ( rule__NameExpression__Alternatives_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4658:1: ( ( rule__NameExpression__Alternatives_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4658:1: ( ( rule__NameExpression__Alternatives_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4659:1: ( rule__NameExpression__Alternatives_0 )

+            {

+             before(grammarAccess.getNameExpressionAccess().getAlternatives_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4660:1: ( rule__NameExpression__Alternatives_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4660:2: rule__NameExpression__Alternatives_0

+            {

+            pushFollow(FOLLOW_rule__NameExpression__Alternatives_0_in_rule__NameExpression__Group__0__Impl10153);

+            rule__NameExpression__Alternatives_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNameExpressionAccess().getAlternatives_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__NameExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4670:1: rule__NameExpression__Group__1 : rule__NameExpression__Group__1__Impl ;

+    public final void rule__NameExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4674:1: ( rule__NameExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4675:2: rule__NameExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__NameExpression__Group__1__Impl_in_rule__NameExpression__Group__110183);

+            rule__NameExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group__1"

+

+

+    // $ANTLR start "rule__NameExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4681:1: rule__NameExpression__Group__1__Impl : ( ( rule__NameExpression__SuffixAssignment_1 )? ) ;

+    public final void rule__NameExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4685:1: ( ( ( rule__NameExpression__SuffixAssignment_1 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4686:1: ( ( rule__NameExpression__SuffixAssignment_1 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4686:1: ( ( rule__NameExpression__SuffixAssignment_1 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4687:1: ( rule__NameExpression__SuffixAssignment_1 )?

+            {

+             before(grammarAccess.getNameExpressionAccess().getSuffixAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4688:1: ( rule__NameExpression__SuffixAssignment_1 )?

+            int alt44=2;

+            int LA44_0 = input.LA(1);

+

+            if ( (LA44_0==77||LA44_0==80) ) {

+                alt44=1;

+            }

+            switch (alt44) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4688:2: rule__NameExpression__SuffixAssignment_1

+                    {

+                    pushFollow(FOLLOW_rule__NameExpression__SuffixAssignment_1_in_rule__NameExpression__Group__1__Impl10210);

+                    rule__NameExpression__SuffixAssignment_1();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getNameExpressionAccess().getSuffixAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__NameExpression__Group_0_0__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4702:1: rule__NameExpression__Group_0_0__0 : rule__NameExpression__Group_0_0__0__Impl rule__NameExpression__Group_0_0__1 ;

+    public final void rule__NameExpression__Group_0_0__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4706:1: ( rule__NameExpression__Group_0_0__0__Impl rule__NameExpression__Group_0_0__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4707:2: rule__NameExpression__Group_0_0__0__Impl rule__NameExpression__Group_0_0__1

+            {

+            pushFollow(FOLLOW_rule__NameExpression__Group_0_0__0__Impl_in_rule__NameExpression__Group_0_0__010245);

+            rule__NameExpression__Group_0_0__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__NameExpression__Group_0_0__1_in_rule__NameExpression__Group_0_0__010248);

+            rule__NameExpression__Group_0_0__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group_0_0__0"

+

+

+    // $ANTLR start "rule__NameExpression__Group_0_0__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4714:1: rule__NameExpression__Group_0_0__0__Impl : ( ( rule__NameExpression__PrefixOpAssignment_0_0_0 ) ) ;

+    public final void rule__NameExpression__Group_0_0__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4718:1: ( ( ( rule__NameExpression__PrefixOpAssignment_0_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4719:1: ( ( rule__NameExpression__PrefixOpAssignment_0_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4719:1: ( ( rule__NameExpression__PrefixOpAssignment_0_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4720:1: ( rule__NameExpression__PrefixOpAssignment_0_0_0 )

+            {

+             before(grammarAccess.getNameExpressionAccess().getPrefixOpAssignment_0_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4721:1: ( rule__NameExpression__PrefixOpAssignment_0_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4721:2: rule__NameExpression__PrefixOpAssignment_0_0_0

+            {

+            pushFollow(FOLLOW_rule__NameExpression__PrefixOpAssignment_0_0_0_in_rule__NameExpression__Group_0_0__0__Impl10275);

+            rule__NameExpression__PrefixOpAssignment_0_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNameExpressionAccess().getPrefixOpAssignment_0_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group_0_0__0__Impl"

+

+

+    // $ANTLR start "rule__NameExpression__Group_0_0__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4731:1: rule__NameExpression__Group_0_0__1 : rule__NameExpression__Group_0_0__1__Impl rule__NameExpression__Group_0_0__2 ;

+    public final void rule__NameExpression__Group_0_0__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4735:1: ( rule__NameExpression__Group_0_0__1__Impl rule__NameExpression__Group_0_0__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4736:2: rule__NameExpression__Group_0_0__1__Impl rule__NameExpression__Group_0_0__2

+            {

+            pushFollow(FOLLOW_rule__NameExpression__Group_0_0__1__Impl_in_rule__NameExpression__Group_0_0__110305);

+            rule__NameExpression__Group_0_0__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__NameExpression__Group_0_0__2_in_rule__NameExpression__Group_0_0__110308);

+            rule__NameExpression__Group_0_0__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group_0_0__1"

+

+

+    // $ANTLR start "rule__NameExpression__Group_0_0__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4743:1: rule__NameExpression__Group_0_0__1__Impl : ( ( rule__NameExpression__PathAssignment_0_0_1 )? ) ;

+    public final void rule__NameExpression__Group_0_0__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4747:1: ( ( ( rule__NameExpression__PathAssignment_0_0_1 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4748:1: ( ( rule__NameExpression__PathAssignment_0_0_1 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4748:1: ( ( rule__NameExpression__PathAssignment_0_0_1 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4749:1: ( rule__NameExpression__PathAssignment_0_0_1 )?

+            {

+             before(grammarAccess.getNameExpressionAccess().getPathAssignment_0_0_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4750:1: ( rule__NameExpression__PathAssignment_0_0_1 )?

+            int alt45=2;

+            int LA45_0 = input.LA(1);

+

+            if ( (LA45_0==RULE_ID) ) {

+                int LA45_1 = input.LA(2);

+

+                if ( (LA45_1==18) ) {

+                    int LA45_2 = input.LA(3);

+

+                    if ( (LA45_2==RULE_ID) ) {

+                        int LA45_5 = input.LA(4);

+

+                        if ( (LA45_5==67) ) {

+                            alt45=1;

+                        }

+                    }

+                }

+                else if ( (LA45_1==65) ) {

+                    alt45=1;

+                }

+            }

+            switch (alt45) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4750:2: rule__NameExpression__PathAssignment_0_0_1

+                    {

+                    pushFollow(FOLLOW_rule__NameExpression__PathAssignment_0_0_1_in_rule__NameExpression__Group_0_0__1__Impl10335);

+                    rule__NameExpression__PathAssignment_0_0_1();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getNameExpressionAccess().getPathAssignment_0_0_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group_0_0__1__Impl"

+

+

+    // $ANTLR start "rule__NameExpression__Group_0_0__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4760:1: rule__NameExpression__Group_0_0__2 : rule__NameExpression__Group_0_0__2__Impl ;

+    public final void rule__NameExpression__Group_0_0__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4764:1: ( rule__NameExpression__Group_0_0__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4765:2: rule__NameExpression__Group_0_0__2__Impl

+            {

+            pushFollow(FOLLOW_rule__NameExpression__Group_0_0__2__Impl_in_rule__NameExpression__Group_0_0__210366);

+            rule__NameExpression__Group_0_0__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group_0_0__2"

+

+

+    // $ANTLR start "rule__NameExpression__Group_0_0__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4771:1: rule__NameExpression__Group_0_0__2__Impl : ( ( rule__NameExpression__IdAssignment_0_0_2 ) ) ;

+    public final void rule__NameExpression__Group_0_0__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4775:1: ( ( ( rule__NameExpression__IdAssignment_0_0_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4776:1: ( ( rule__NameExpression__IdAssignment_0_0_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4776:1: ( ( rule__NameExpression__IdAssignment_0_0_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4777:1: ( rule__NameExpression__IdAssignment_0_0_2 )

+            {

+             before(grammarAccess.getNameExpressionAccess().getIdAssignment_0_0_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4778:1: ( rule__NameExpression__IdAssignment_0_0_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4778:2: rule__NameExpression__IdAssignment_0_0_2

+            {

+            pushFollow(FOLLOW_rule__NameExpression__IdAssignment_0_0_2_in_rule__NameExpression__Group_0_0__2__Impl10393);

+            rule__NameExpression__IdAssignment_0_0_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNameExpressionAccess().getIdAssignment_0_0_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group_0_0__2__Impl"

+

+

+    // $ANTLR start "rule__NameExpression__Group_0_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4794:1: rule__NameExpression__Group_0_1__0 : rule__NameExpression__Group_0_1__0__Impl rule__NameExpression__Group_0_1__1 ;

+    public final void rule__NameExpression__Group_0_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4798:1: ( rule__NameExpression__Group_0_1__0__Impl rule__NameExpression__Group_0_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4799:2: rule__NameExpression__Group_0_1__0__Impl rule__NameExpression__Group_0_1__1

+            {

+            pushFollow(FOLLOW_rule__NameExpression__Group_0_1__0__Impl_in_rule__NameExpression__Group_0_1__010429);

+            rule__NameExpression__Group_0_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__NameExpression__Group_0_1__1_in_rule__NameExpression__Group_0_1__010432);

+            rule__NameExpression__Group_0_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group_0_1__0"

+

+

+    // $ANTLR start "rule__NameExpression__Group_0_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4806:1: rule__NameExpression__Group_0_1__0__Impl : ( ( rule__NameExpression__PathAssignment_0_1_0 )? ) ;

+    public final void rule__NameExpression__Group_0_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4810:1: ( ( ( rule__NameExpression__PathAssignment_0_1_0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4811:1: ( ( rule__NameExpression__PathAssignment_0_1_0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4811:1: ( ( rule__NameExpression__PathAssignment_0_1_0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4812:1: ( rule__NameExpression__PathAssignment_0_1_0 )?

+            {

+             before(grammarAccess.getNameExpressionAccess().getPathAssignment_0_1_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4813:1: ( rule__NameExpression__PathAssignment_0_1_0 )?

+            int alt46=2;

+            int LA46_0 = input.LA(1);

+

+            if ( (LA46_0==RULE_ID) ) {

+                int LA46_1 = input.LA(2);

+

+                if ( (LA46_1==18) ) {

+                    int LA46_3 = input.LA(3);

+

+                    if ( (LA46_3==RULE_ID) ) {

+                        int LA46_5 = input.LA(4);

+

+                        if ( (LA46_5==67) ) {

+                            alt46=1;

+                        }

+                    }

+                }

+                else if ( (LA46_1==65) ) {

+                    alt46=1;

+                }

+            }

+            switch (alt46) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4813:2: rule__NameExpression__PathAssignment_0_1_0

+                    {

+                    pushFollow(FOLLOW_rule__NameExpression__PathAssignment_0_1_0_in_rule__NameExpression__Group_0_1__0__Impl10459);

+                    rule__NameExpression__PathAssignment_0_1_0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getNameExpressionAccess().getPathAssignment_0_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group_0_1__0__Impl"

+

+

+    // $ANTLR start "rule__NameExpression__Group_0_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4823:1: rule__NameExpression__Group_0_1__1 : rule__NameExpression__Group_0_1__1__Impl rule__NameExpression__Group_0_1__2 ;

+    public final void rule__NameExpression__Group_0_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4827:1: ( rule__NameExpression__Group_0_1__1__Impl rule__NameExpression__Group_0_1__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4828:2: rule__NameExpression__Group_0_1__1__Impl rule__NameExpression__Group_0_1__2

+            {

+            pushFollow(FOLLOW_rule__NameExpression__Group_0_1__1__Impl_in_rule__NameExpression__Group_0_1__110490);

+            rule__NameExpression__Group_0_1__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__NameExpression__Group_0_1__2_in_rule__NameExpression__Group_0_1__110493);

+            rule__NameExpression__Group_0_1__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group_0_1__1"

+

+

+    // $ANTLR start "rule__NameExpression__Group_0_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4835:1: rule__NameExpression__Group_0_1__1__Impl : ( ( rule__NameExpression__IdAssignment_0_1_1 ) ) ;

+    public final void rule__NameExpression__Group_0_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4839:1: ( ( ( rule__NameExpression__IdAssignment_0_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4840:1: ( ( rule__NameExpression__IdAssignment_0_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4840:1: ( ( rule__NameExpression__IdAssignment_0_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4841:1: ( rule__NameExpression__IdAssignment_0_1_1 )

+            {

+             before(grammarAccess.getNameExpressionAccess().getIdAssignment_0_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4842:1: ( rule__NameExpression__IdAssignment_0_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4842:2: rule__NameExpression__IdAssignment_0_1_1

+            {

+            pushFollow(FOLLOW_rule__NameExpression__IdAssignment_0_1_1_in_rule__NameExpression__Group_0_1__1__Impl10520);

+            rule__NameExpression__IdAssignment_0_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNameExpressionAccess().getIdAssignment_0_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group_0_1__1__Impl"

+

+

+    // $ANTLR start "rule__NameExpression__Group_0_1__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4852:1: rule__NameExpression__Group_0_1__2 : rule__NameExpression__Group_0_1__2__Impl ;

+    public final void rule__NameExpression__Group_0_1__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4856:1: ( rule__NameExpression__Group_0_1__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4857:2: rule__NameExpression__Group_0_1__2__Impl

+            {

+            pushFollow(FOLLOW_rule__NameExpression__Group_0_1__2__Impl_in_rule__NameExpression__Group_0_1__210550);

+            rule__NameExpression__Group_0_1__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group_0_1__2"

+

+

+    // $ANTLR start "rule__NameExpression__Group_0_1__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4863:1: rule__NameExpression__Group_0_1__2__Impl : ( ( rule__NameExpression__Alternatives_0_1_2 )? ) ;

+    public final void rule__NameExpression__Group_0_1__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4867:1: ( ( ( rule__NameExpression__Alternatives_0_1_2 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4868:1: ( ( rule__NameExpression__Alternatives_0_1_2 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4868:1: ( ( rule__NameExpression__Alternatives_0_1_2 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4869:1: ( rule__NameExpression__Alternatives_0_1_2 )?

+            {

+             before(grammarAccess.getNameExpressionAccess().getAlternatives_0_1_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4870:1: ( rule__NameExpression__Alternatives_0_1_2 )?

+            int alt47=2;

+            int LA47_0 = input.LA(1);

+

+            if ( ((LA47_0>=12 && LA47_0<=13)||LA47_0==68||LA47_0==87) ) {

+                alt47=1;

+            }

+            else if ( (LA47_0==78) ) {

+                int LA47_2 = input.LA(2);

+

+                if ( ((LA47_2>=RULE_INTEGERVALUE && LA47_2<=RULE_ID)||(LA47_2>=12 && LA47_2<=13)||(LA47_2>=25 && LA47_2<=27)||(LA47_2>=30 && LA47_2<=34)||LA47_2==68||(LA47_2>=83 && LA47_2<=86)) ) {

+                    alt47=1;

+                }

+                else if ( (LA47_2==79) ) {

+                    int LA47_4 = input.LA(3);

+

+                    if ( (LA47_4==87) ) {

+                        alt47=1;

+                    }

+                }

+            }

+            switch (alt47) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4870:2: rule__NameExpression__Alternatives_0_1_2

+                    {

+                    pushFollow(FOLLOW_rule__NameExpression__Alternatives_0_1_2_in_rule__NameExpression__Group_0_1__2__Impl10577);

+                    rule__NameExpression__Alternatives_0_1_2();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getNameExpressionAccess().getAlternatives_0_1_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__Group_0_1__2__Impl"

+

+

+    // $ANTLR start "rule__QualifiedNamePath__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4886:1: rule__QualifiedNamePath__Group__0 : rule__QualifiedNamePath__Group__0__Impl rule__QualifiedNamePath__Group__1 ;

+    public final void rule__QualifiedNamePath__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4890:1: ( rule__QualifiedNamePath__Group__0__Impl rule__QualifiedNamePath__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4891:2: rule__QualifiedNamePath__Group__0__Impl rule__QualifiedNamePath__Group__1

+            {

+            pushFollow(FOLLOW_rule__QualifiedNamePath__Group__0__Impl_in_rule__QualifiedNamePath__Group__010614);

+            rule__QualifiedNamePath__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__QualifiedNamePath__Group__1_in_rule__QualifiedNamePath__Group__010617);

+            rule__QualifiedNamePath__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNamePath__Group__0"

+

+

+    // $ANTLR start "rule__QualifiedNamePath__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4898:1: rule__QualifiedNamePath__Group__0__Impl : ( ( rule__QualifiedNamePath__NamespaceAssignment_0 ) ) ;

+    public final void rule__QualifiedNamePath__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4902:1: ( ( ( rule__QualifiedNamePath__NamespaceAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4903:1: ( ( rule__QualifiedNamePath__NamespaceAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4903:1: ( ( rule__QualifiedNamePath__NamespaceAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4904:1: ( rule__QualifiedNamePath__NamespaceAssignment_0 )

+            {

+             before(grammarAccess.getQualifiedNamePathAccess().getNamespaceAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4905:1: ( rule__QualifiedNamePath__NamespaceAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4905:2: rule__QualifiedNamePath__NamespaceAssignment_0

+            {

+            pushFollow(FOLLOW_rule__QualifiedNamePath__NamespaceAssignment_0_in_rule__QualifiedNamePath__Group__0__Impl10644);

+            rule__QualifiedNamePath__NamespaceAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getQualifiedNamePathAccess().getNamespaceAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNamePath__Group__0__Impl"

+

+

+    // $ANTLR start "rule__QualifiedNamePath__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4915:1: rule__QualifiedNamePath__Group__1 : rule__QualifiedNamePath__Group__1__Impl ;

+    public final void rule__QualifiedNamePath__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4919:1: ( rule__QualifiedNamePath__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4920:2: rule__QualifiedNamePath__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__QualifiedNamePath__Group__1__Impl_in_rule__QualifiedNamePath__Group__110674);

+            rule__QualifiedNamePath__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNamePath__Group__1"

+

+

+    // $ANTLR start "rule__QualifiedNamePath__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4926:1: rule__QualifiedNamePath__Group__1__Impl : ( '::' ) ;

+    public final void rule__QualifiedNamePath__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4930:1: ( ( '::' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4931:1: ( '::' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4931:1: ( '::' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4932:1: '::'

+            {

+             before(grammarAccess.getQualifiedNamePathAccess().getColonColonKeyword_1()); 

+            match(input,65,FOLLOW_65_in_rule__QualifiedNamePath__Group__1__Impl10702); 

+             after(grammarAccess.getQualifiedNamePathAccess().getColonColonKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNamePath__Group__1__Impl"

+

+

+    // $ANTLR start "rule__UnqualifiedName__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4949:1: rule__UnqualifiedName__Group__0 : rule__UnqualifiedName__Group__0__Impl rule__UnqualifiedName__Group__1 ;

+    public final void rule__UnqualifiedName__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4953:1: ( rule__UnqualifiedName__Group__0__Impl rule__UnqualifiedName__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4954:2: rule__UnqualifiedName__Group__0__Impl rule__UnqualifiedName__Group__1

+            {

+            pushFollow(FOLLOW_rule__UnqualifiedName__Group__0__Impl_in_rule__UnqualifiedName__Group__010737);

+            rule__UnqualifiedName__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__UnqualifiedName__Group__1_in_rule__UnqualifiedName__Group__010740);

+            rule__UnqualifiedName__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UnqualifiedName__Group__0"

+

+

+    // $ANTLR start "rule__UnqualifiedName__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4961:1: rule__UnqualifiedName__Group__0__Impl : ( ( rule__UnqualifiedName__NameAssignment_0 ) ) ;

+    public final void rule__UnqualifiedName__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4965:1: ( ( ( rule__UnqualifiedName__NameAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4966:1: ( ( rule__UnqualifiedName__NameAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4966:1: ( ( rule__UnqualifiedName__NameAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4967:1: ( rule__UnqualifiedName__NameAssignment_0 )

+            {

+             before(grammarAccess.getUnqualifiedNameAccess().getNameAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4968:1: ( rule__UnqualifiedName__NameAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4968:2: rule__UnqualifiedName__NameAssignment_0

+            {

+            pushFollow(FOLLOW_rule__UnqualifiedName__NameAssignment_0_in_rule__UnqualifiedName__Group__0__Impl10767);

+            rule__UnqualifiedName__NameAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getUnqualifiedNameAccess().getNameAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UnqualifiedName__Group__0__Impl"

+

+

+    // $ANTLR start "rule__UnqualifiedName__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4978:1: rule__UnqualifiedName__Group__1 : rule__UnqualifiedName__Group__1__Impl ;

+    public final void rule__UnqualifiedName__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4982:1: ( rule__UnqualifiedName__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4983:2: rule__UnqualifiedName__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__UnqualifiedName__Group__1__Impl_in_rule__UnqualifiedName__Group__110797);

+            rule__UnqualifiedName__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UnqualifiedName__Group__1"

+

+

+    // $ANTLR start "rule__UnqualifiedName__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4989:1: rule__UnqualifiedName__Group__1__Impl : ( ( rule__UnqualifiedName__TemplateBindingAssignment_1 )? ) ;

+    public final void rule__UnqualifiedName__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4993:1: ( ( ( rule__UnqualifiedName__TemplateBindingAssignment_1 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4994:1: ( ( rule__UnqualifiedName__TemplateBindingAssignment_1 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4994:1: ( ( rule__UnqualifiedName__TemplateBindingAssignment_1 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4995:1: ( rule__UnqualifiedName__TemplateBindingAssignment_1 )?

+            {

+             before(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4996:1: ( rule__UnqualifiedName__TemplateBindingAssignment_1 )?

+            int alt48=2;

+            int LA48_0 = input.LA(1);

+

+            if ( (LA48_0==18) ) {

+                alt48=1;

+            }

+            switch (alt48) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:4996:2: rule__UnqualifiedName__TemplateBindingAssignment_1

+                    {

+                    pushFollow(FOLLOW_rule__UnqualifiedName__TemplateBindingAssignment_1_in_rule__UnqualifiedName__Group__1__Impl10824);

+                    rule__UnqualifiedName__TemplateBindingAssignment_1();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UnqualifiedName__Group__1__Impl"

+

+

+    // $ANTLR start "rule__TemplateBinding__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5010:1: rule__TemplateBinding__Group__0 : rule__TemplateBinding__Group__0__Impl rule__TemplateBinding__Group__1 ;

+    public final void rule__TemplateBinding__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5014:1: ( rule__TemplateBinding__Group__0__Impl rule__TemplateBinding__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5015:2: rule__TemplateBinding__Group__0__Impl rule__TemplateBinding__Group__1

+            {

+            pushFollow(FOLLOW_rule__TemplateBinding__Group__0__Impl_in_rule__TemplateBinding__Group__010859);

+            rule__TemplateBinding__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__TemplateBinding__Group__1_in_rule__TemplateBinding__Group__010862);

+            rule__TemplateBinding__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__Group__0"

+

+

+    // $ANTLR start "rule__TemplateBinding__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5022:1: rule__TemplateBinding__Group__0__Impl : ( '<' ) ;

+    public final void rule__TemplateBinding__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5026:1: ( ( '<' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5027:1: ( '<' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5027:1: ( '<' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5028:1: '<'

+            {

+             before(grammarAccess.getTemplateBindingAccess().getLessThanSignKeyword_0()); 

+            match(input,18,FOLLOW_18_in_rule__TemplateBinding__Group__0__Impl10890); 

+             after(grammarAccess.getTemplateBindingAccess().getLessThanSignKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__Group__0__Impl"

+

+

+    // $ANTLR start "rule__TemplateBinding__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5041:1: rule__TemplateBinding__Group__1 : rule__TemplateBinding__Group__1__Impl rule__TemplateBinding__Group__2 ;

+    public final void rule__TemplateBinding__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5045:1: ( rule__TemplateBinding__Group__1__Impl rule__TemplateBinding__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5046:2: rule__TemplateBinding__Group__1__Impl rule__TemplateBinding__Group__2

+            {

+            pushFollow(FOLLOW_rule__TemplateBinding__Group__1__Impl_in_rule__TemplateBinding__Group__110921);

+            rule__TemplateBinding__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__TemplateBinding__Group__2_in_rule__TemplateBinding__Group__110924);

+            rule__TemplateBinding__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__Group__1"

+

+

+    // $ANTLR start "rule__TemplateBinding__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5053:1: rule__TemplateBinding__Group__1__Impl : ( ( rule__TemplateBinding__BindingsAssignment_1 ) ) ;

+    public final void rule__TemplateBinding__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5057:1: ( ( ( rule__TemplateBinding__BindingsAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5058:1: ( ( rule__TemplateBinding__BindingsAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5058:1: ( ( rule__TemplateBinding__BindingsAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5059:1: ( rule__TemplateBinding__BindingsAssignment_1 )

+            {

+             before(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5060:1: ( rule__TemplateBinding__BindingsAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5060:2: rule__TemplateBinding__BindingsAssignment_1

+            {

+            pushFollow(FOLLOW_rule__TemplateBinding__BindingsAssignment_1_in_rule__TemplateBinding__Group__1__Impl10951);

+            rule__TemplateBinding__BindingsAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__Group__1__Impl"

+

+

+    // $ANTLR start "rule__TemplateBinding__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5070:1: rule__TemplateBinding__Group__2 : rule__TemplateBinding__Group__2__Impl rule__TemplateBinding__Group__3 ;

+    public final void rule__TemplateBinding__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5074:1: ( rule__TemplateBinding__Group__2__Impl rule__TemplateBinding__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5075:2: rule__TemplateBinding__Group__2__Impl rule__TemplateBinding__Group__3

+            {

+            pushFollow(FOLLOW_rule__TemplateBinding__Group__2__Impl_in_rule__TemplateBinding__Group__210981);

+            rule__TemplateBinding__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__TemplateBinding__Group__3_in_rule__TemplateBinding__Group__210984);

+            rule__TemplateBinding__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__Group__2"

+

+

+    // $ANTLR start "rule__TemplateBinding__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5082:1: rule__TemplateBinding__Group__2__Impl : ( ( rule__TemplateBinding__Group_2__0 )* ) ;

+    public final void rule__TemplateBinding__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5086:1: ( ( ( rule__TemplateBinding__Group_2__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5087:1: ( ( rule__TemplateBinding__Group_2__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5087:1: ( ( rule__TemplateBinding__Group_2__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5088:1: ( rule__TemplateBinding__Group_2__0 )*

+            {

+             before(grammarAccess.getTemplateBindingAccess().getGroup_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5089:1: ( rule__TemplateBinding__Group_2__0 )*

+            loop49:

+            do {

+                int alt49=2;

+                int LA49_0 = input.LA(1);

+

+                if ( (LA49_0==66) ) {

+                    alt49=1;

+                }

+

+

+                switch (alt49) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5089:2: rule__TemplateBinding__Group_2__0

+            	    {

+            	    pushFollow(FOLLOW_rule__TemplateBinding__Group_2__0_in_rule__TemplateBinding__Group__2__Impl11011);

+            	    rule__TemplateBinding__Group_2__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop49;

+                }

+            } while (true);

+

+             after(grammarAccess.getTemplateBindingAccess().getGroup_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__Group__2__Impl"

+

+

+    // $ANTLR start "rule__TemplateBinding__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5099:1: rule__TemplateBinding__Group__3 : rule__TemplateBinding__Group__3__Impl ;

+    public final void rule__TemplateBinding__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5103:1: ( rule__TemplateBinding__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5104:2: rule__TemplateBinding__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__TemplateBinding__Group__3__Impl_in_rule__TemplateBinding__Group__311042);

+            rule__TemplateBinding__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__Group__3"

+

+

+    // $ANTLR start "rule__TemplateBinding__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5110:1: rule__TemplateBinding__Group__3__Impl : ( '>' ) ;

+    public final void rule__TemplateBinding__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5114:1: ( ( '>' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5115:1: ( '>' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5115:1: ( '>' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5116:1: '>'

+            {

+             before(grammarAccess.getTemplateBindingAccess().getGreaterThanSignKeyword_3()); 

+            match(input,19,FOLLOW_19_in_rule__TemplateBinding__Group__3__Impl11070); 

+             after(grammarAccess.getTemplateBindingAccess().getGreaterThanSignKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__Group__3__Impl"

+

+

+    // $ANTLR start "rule__TemplateBinding__Group_2__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5137:1: rule__TemplateBinding__Group_2__0 : rule__TemplateBinding__Group_2__0__Impl rule__TemplateBinding__Group_2__1 ;

+    public final void rule__TemplateBinding__Group_2__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5141:1: ( rule__TemplateBinding__Group_2__0__Impl rule__TemplateBinding__Group_2__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5142:2: rule__TemplateBinding__Group_2__0__Impl rule__TemplateBinding__Group_2__1

+            {

+            pushFollow(FOLLOW_rule__TemplateBinding__Group_2__0__Impl_in_rule__TemplateBinding__Group_2__011109);

+            rule__TemplateBinding__Group_2__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__TemplateBinding__Group_2__1_in_rule__TemplateBinding__Group_2__011112);

+            rule__TemplateBinding__Group_2__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__Group_2__0"

+

+

+    // $ANTLR start "rule__TemplateBinding__Group_2__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5149:1: rule__TemplateBinding__Group_2__0__Impl : ( ',' ) ;

+    public final void rule__TemplateBinding__Group_2__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5153:1: ( ( ',' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5154:1: ( ',' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5154:1: ( ',' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5155:1: ','

+            {

+             before(grammarAccess.getTemplateBindingAccess().getCommaKeyword_2_0()); 

+            match(input,66,FOLLOW_66_in_rule__TemplateBinding__Group_2__0__Impl11140); 

+             after(grammarAccess.getTemplateBindingAccess().getCommaKeyword_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__Group_2__0__Impl"

+

+

+    // $ANTLR start "rule__TemplateBinding__Group_2__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5168:1: rule__TemplateBinding__Group_2__1 : rule__TemplateBinding__Group_2__1__Impl ;

+    public final void rule__TemplateBinding__Group_2__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5172:1: ( rule__TemplateBinding__Group_2__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5173:2: rule__TemplateBinding__Group_2__1__Impl

+            {

+            pushFollow(FOLLOW_rule__TemplateBinding__Group_2__1__Impl_in_rule__TemplateBinding__Group_2__111171);

+            rule__TemplateBinding__Group_2__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__Group_2__1"

+

+

+    // $ANTLR start "rule__TemplateBinding__Group_2__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5179:1: rule__TemplateBinding__Group_2__1__Impl : ( ( rule__TemplateBinding__BindingsAssignment_2_1 ) ) ;

+    public final void rule__TemplateBinding__Group_2__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5183:1: ( ( ( rule__TemplateBinding__BindingsAssignment_2_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5184:1: ( ( rule__TemplateBinding__BindingsAssignment_2_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5184:1: ( ( rule__TemplateBinding__BindingsAssignment_2_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5185:1: ( rule__TemplateBinding__BindingsAssignment_2_1 )

+            {

+             before(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_2_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5186:1: ( rule__TemplateBinding__BindingsAssignment_2_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5186:2: rule__TemplateBinding__BindingsAssignment_2_1

+            {

+            pushFollow(FOLLOW_rule__TemplateBinding__BindingsAssignment_2_1_in_rule__TemplateBinding__Group_2__1__Impl11198);

+            rule__TemplateBinding__BindingsAssignment_2_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getTemplateBindingAccess().getBindingsAssignment_2_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__Group_2__1__Impl"

+

+

+    // $ANTLR start "rule__NamedTemplateBinding__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5200:1: rule__NamedTemplateBinding__Group__0 : rule__NamedTemplateBinding__Group__0__Impl rule__NamedTemplateBinding__Group__1 ;

+    public final void rule__NamedTemplateBinding__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5204:1: ( rule__NamedTemplateBinding__Group__0__Impl rule__NamedTemplateBinding__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5205:2: rule__NamedTemplateBinding__Group__0__Impl rule__NamedTemplateBinding__Group__1

+            {

+            pushFollow(FOLLOW_rule__NamedTemplateBinding__Group__0__Impl_in_rule__NamedTemplateBinding__Group__011232);

+            rule__NamedTemplateBinding__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__NamedTemplateBinding__Group__1_in_rule__NamedTemplateBinding__Group__011235);

+            rule__NamedTemplateBinding__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NamedTemplateBinding__Group__0"

+

+

+    // $ANTLR start "rule__NamedTemplateBinding__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5212:1: rule__NamedTemplateBinding__Group__0__Impl : ( ( rule__NamedTemplateBinding__FormalAssignment_0 ) ) ;

+    public final void rule__NamedTemplateBinding__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5216:1: ( ( ( rule__NamedTemplateBinding__FormalAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5217:1: ( ( rule__NamedTemplateBinding__FormalAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5217:1: ( ( rule__NamedTemplateBinding__FormalAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5218:1: ( rule__NamedTemplateBinding__FormalAssignment_0 )

+            {

+             before(grammarAccess.getNamedTemplateBindingAccess().getFormalAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5219:1: ( rule__NamedTemplateBinding__FormalAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5219:2: rule__NamedTemplateBinding__FormalAssignment_0

+            {

+            pushFollow(FOLLOW_rule__NamedTemplateBinding__FormalAssignment_0_in_rule__NamedTemplateBinding__Group__0__Impl11262);

+            rule__NamedTemplateBinding__FormalAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNamedTemplateBindingAccess().getFormalAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NamedTemplateBinding__Group__0__Impl"

+

+

+    // $ANTLR start "rule__NamedTemplateBinding__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5229:1: rule__NamedTemplateBinding__Group__1 : rule__NamedTemplateBinding__Group__1__Impl rule__NamedTemplateBinding__Group__2 ;

+    public final void rule__NamedTemplateBinding__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5233:1: ( rule__NamedTemplateBinding__Group__1__Impl rule__NamedTemplateBinding__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5234:2: rule__NamedTemplateBinding__Group__1__Impl rule__NamedTemplateBinding__Group__2

+            {

+            pushFollow(FOLLOW_rule__NamedTemplateBinding__Group__1__Impl_in_rule__NamedTemplateBinding__Group__111292);

+            rule__NamedTemplateBinding__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__NamedTemplateBinding__Group__2_in_rule__NamedTemplateBinding__Group__111295);

+            rule__NamedTemplateBinding__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NamedTemplateBinding__Group__1"

+

+

+    // $ANTLR start "rule__NamedTemplateBinding__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5241:1: rule__NamedTemplateBinding__Group__1__Impl : ( '=>' ) ;

+    public final void rule__NamedTemplateBinding__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5245:1: ( ( '=>' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5246:1: ( '=>' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5246:1: ( '=>' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5247:1: '=>'

+            {

+             before(grammarAccess.getNamedTemplateBindingAccess().getEqualsSignGreaterThanSignKeyword_1()); 

+            match(input,67,FOLLOW_67_in_rule__NamedTemplateBinding__Group__1__Impl11323); 

+             after(grammarAccess.getNamedTemplateBindingAccess().getEqualsSignGreaterThanSignKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NamedTemplateBinding__Group__1__Impl"

+

+

+    // $ANTLR start "rule__NamedTemplateBinding__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5260:1: rule__NamedTemplateBinding__Group__2 : rule__NamedTemplateBinding__Group__2__Impl ;

+    public final void rule__NamedTemplateBinding__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5264:1: ( rule__NamedTemplateBinding__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5265:2: rule__NamedTemplateBinding__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__NamedTemplateBinding__Group__2__Impl_in_rule__NamedTemplateBinding__Group__211354);

+            rule__NamedTemplateBinding__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NamedTemplateBinding__Group__2"

+

+

+    // $ANTLR start "rule__NamedTemplateBinding__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5271:1: rule__NamedTemplateBinding__Group__2__Impl : ( ( rule__NamedTemplateBinding__ActualAssignment_2 ) ) ;

+    public final void rule__NamedTemplateBinding__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5275:1: ( ( ( rule__NamedTemplateBinding__ActualAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5276:1: ( ( rule__NamedTemplateBinding__ActualAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5276:1: ( ( rule__NamedTemplateBinding__ActualAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5277:1: ( rule__NamedTemplateBinding__ActualAssignment_2 )

+            {

+             before(grammarAccess.getNamedTemplateBindingAccess().getActualAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5278:1: ( rule__NamedTemplateBinding__ActualAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5278:2: rule__NamedTemplateBinding__ActualAssignment_2

+            {

+            pushFollow(FOLLOW_rule__NamedTemplateBinding__ActualAssignment_2_in_rule__NamedTemplateBinding__Group__2__Impl11381);

+            rule__NamedTemplateBinding__ActualAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNamedTemplateBindingAccess().getActualAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NamedTemplateBinding__Group__2__Impl"

+

+

+    // $ANTLR start "rule__QualifiedNameWithBinding__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5294:1: rule__QualifiedNameWithBinding__Group__0 : rule__QualifiedNameWithBinding__Group__0__Impl rule__QualifiedNameWithBinding__Group__1 ;

+    public final void rule__QualifiedNameWithBinding__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5298:1: ( rule__QualifiedNameWithBinding__Group__0__Impl rule__QualifiedNameWithBinding__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5299:2: rule__QualifiedNameWithBinding__Group__0__Impl rule__QualifiedNameWithBinding__Group__1

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameWithBinding__Group__0__Impl_in_rule__QualifiedNameWithBinding__Group__011417);

+            rule__QualifiedNameWithBinding__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__QualifiedNameWithBinding__Group__1_in_rule__QualifiedNameWithBinding__Group__011420);

+            rule__QualifiedNameWithBinding__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameWithBinding__Group__0"

+

+

+    // $ANTLR start "rule__QualifiedNameWithBinding__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5306:1: rule__QualifiedNameWithBinding__Group__0__Impl : ( ( rule__QualifiedNameWithBinding__IdAssignment_0 ) ) ;

+    public final void rule__QualifiedNameWithBinding__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5310:1: ( ( ( rule__QualifiedNameWithBinding__IdAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5311:1: ( ( rule__QualifiedNameWithBinding__IdAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5311:1: ( ( rule__QualifiedNameWithBinding__IdAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5312:1: ( rule__QualifiedNameWithBinding__IdAssignment_0 )

+            {

+             before(grammarAccess.getQualifiedNameWithBindingAccess().getIdAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5313:1: ( rule__QualifiedNameWithBinding__IdAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5313:2: rule__QualifiedNameWithBinding__IdAssignment_0

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameWithBinding__IdAssignment_0_in_rule__QualifiedNameWithBinding__Group__0__Impl11447);

+            rule__QualifiedNameWithBinding__IdAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getQualifiedNameWithBindingAccess().getIdAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameWithBinding__Group__0__Impl"

+

+

+    // $ANTLR start "rule__QualifiedNameWithBinding__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5323:1: rule__QualifiedNameWithBinding__Group__1 : rule__QualifiedNameWithBinding__Group__1__Impl rule__QualifiedNameWithBinding__Group__2 ;

+    public final void rule__QualifiedNameWithBinding__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5327:1: ( rule__QualifiedNameWithBinding__Group__1__Impl rule__QualifiedNameWithBinding__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5328:2: rule__QualifiedNameWithBinding__Group__1__Impl rule__QualifiedNameWithBinding__Group__2

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameWithBinding__Group__1__Impl_in_rule__QualifiedNameWithBinding__Group__111477);

+            rule__QualifiedNameWithBinding__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__QualifiedNameWithBinding__Group__2_in_rule__QualifiedNameWithBinding__Group__111480);

+            rule__QualifiedNameWithBinding__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameWithBinding__Group__1"

+

+

+    // $ANTLR start "rule__QualifiedNameWithBinding__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5335:1: rule__QualifiedNameWithBinding__Group__1__Impl : ( ( rule__QualifiedNameWithBinding__BindingAssignment_1 )? ) ;

+    public final void rule__QualifiedNameWithBinding__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5339:1: ( ( ( rule__QualifiedNameWithBinding__BindingAssignment_1 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5340:1: ( ( rule__QualifiedNameWithBinding__BindingAssignment_1 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5340:1: ( ( rule__QualifiedNameWithBinding__BindingAssignment_1 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5341:1: ( rule__QualifiedNameWithBinding__BindingAssignment_1 )?

+            {

+             before(grammarAccess.getQualifiedNameWithBindingAccess().getBindingAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5342:1: ( rule__QualifiedNameWithBinding__BindingAssignment_1 )?

+            int alt50=2;

+            int LA50_0 = input.LA(1);

+

+            if ( (LA50_0==18) ) {

+                int LA50_1 = input.LA(2);

+

+                if ( (LA50_1==RULE_ID) ) {

+                    int LA50_3 = input.LA(3);

+

+                    if ( (LA50_3==67) ) {

+                        alt50=1;

+                    }

+                }

+            }

+            switch (alt50) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5342:2: rule__QualifiedNameWithBinding__BindingAssignment_1

+                    {

+                    pushFollow(FOLLOW_rule__QualifiedNameWithBinding__BindingAssignment_1_in_rule__QualifiedNameWithBinding__Group__1__Impl11507);

+                    rule__QualifiedNameWithBinding__BindingAssignment_1();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getQualifiedNameWithBindingAccess().getBindingAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameWithBinding__Group__1__Impl"

+

+

+    // $ANTLR start "rule__QualifiedNameWithBinding__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5352:1: rule__QualifiedNameWithBinding__Group__2 : rule__QualifiedNameWithBinding__Group__2__Impl ;

+    public final void rule__QualifiedNameWithBinding__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5356:1: ( rule__QualifiedNameWithBinding__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5357:2: rule__QualifiedNameWithBinding__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameWithBinding__Group__2__Impl_in_rule__QualifiedNameWithBinding__Group__211538);

+            rule__QualifiedNameWithBinding__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameWithBinding__Group__2"

+

+

+    // $ANTLR start "rule__QualifiedNameWithBinding__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5363:1: rule__QualifiedNameWithBinding__Group__2__Impl : ( ( rule__QualifiedNameWithBinding__Group_2__0 )? ) ;

+    public final void rule__QualifiedNameWithBinding__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5367:1: ( ( ( rule__QualifiedNameWithBinding__Group_2__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5368:1: ( ( rule__QualifiedNameWithBinding__Group_2__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5368:1: ( ( rule__QualifiedNameWithBinding__Group_2__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5369:1: ( rule__QualifiedNameWithBinding__Group_2__0 )?

+            {

+             before(grammarAccess.getQualifiedNameWithBindingAccess().getGroup_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5370:1: ( rule__QualifiedNameWithBinding__Group_2__0 )?

+            int alt51=2;

+            int LA51_0 = input.LA(1);

+

+            if ( (LA51_0==65) ) {

+                alt51=1;

+            }

+            switch (alt51) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5370:2: rule__QualifiedNameWithBinding__Group_2__0

+                    {

+                    pushFollow(FOLLOW_rule__QualifiedNameWithBinding__Group_2__0_in_rule__QualifiedNameWithBinding__Group__2__Impl11565);

+                    rule__QualifiedNameWithBinding__Group_2__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getQualifiedNameWithBindingAccess().getGroup_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameWithBinding__Group__2__Impl"

+

+

+    // $ANTLR start "rule__QualifiedNameWithBinding__Group_2__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5386:1: rule__QualifiedNameWithBinding__Group_2__0 : rule__QualifiedNameWithBinding__Group_2__0__Impl rule__QualifiedNameWithBinding__Group_2__1 ;

+    public final void rule__QualifiedNameWithBinding__Group_2__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5390:1: ( rule__QualifiedNameWithBinding__Group_2__0__Impl rule__QualifiedNameWithBinding__Group_2__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5391:2: rule__QualifiedNameWithBinding__Group_2__0__Impl rule__QualifiedNameWithBinding__Group_2__1

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameWithBinding__Group_2__0__Impl_in_rule__QualifiedNameWithBinding__Group_2__011602);

+            rule__QualifiedNameWithBinding__Group_2__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__QualifiedNameWithBinding__Group_2__1_in_rule__QualifiedNameWithBinding__Group_2__011605);

+            rule__QualifiedNameWithBinding__Group_2__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameWithBinding__Group_2__0"

+

+

+    // $ANTLR start "rule__QualifiedNameWithBinding__Group_2__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5398:1: rule__QualifiedNameWithBinding__Group_2__0__Impl : ( '::' ) ;

+    public final void rule__QualifiedNameWithBinding__Group_2__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5402:1: ( ( '::' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5403:1: ( '::' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5403:1: ( '::' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5404:1: '::'

+            {

+             before(grammarAccess.getQualifiedNameWithBindingAccess().getColonColonKeyword_2_0()); 

+            match(input,65,FOLLOW_65_in_rule__QualifiedNameWithBinding__Group_2__0__Impl11633); 

+             after(grammarAccess.getQualifiedNameWithBindingAccess().getColonColonKeyword_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameWithBinding__Group_2__0__Impl"

+

+

+    // $ANTLR start "rule__QualifiedNameWithBinding__Group_2__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5417:1: rule__QualifiedNameWithBinding__Group_2__1 : rule__QualifiedNameWithBinding__Group_2__1__Impl ;

+    public final void rule__QualifiedNameWithBinding__Group_2__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5421:1: ( rule__QualifiedNameWithBinding__Group_2__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5422:2: rule__QualifiedNameWithBinding__Group_2__1__Impl

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameWithBinding__Group_2__1__Impl_in_rule__QualifiedNameWithBinding__Group_2__111664);

+            rule__QualifiedNameWithBinding__Group_2__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameWithBinding__Group_2__1"

+

+

+    // $ANTLR start "rule__QualifiedNameWithBinding__Group_2__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5428:1: rule__QualifiedNameWithBinding__Group_2__1__Impl : ( ( rule__QualifiedNameWithBinding__RemainingAssignment_2_1 ) ) ;

+    public final void rule__QualifiedNameWithBinding__Group_2__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5432:1: ( ( ( rule__QualifiedNameWithBinding__RemainingAssignment_2_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5433:1: ( ( rule__QualifiedNameWithBinding__RemainingAssignment_2_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5433:1: ( ( rule__QualifiedNameWithBinding__RemainingAssignment_2_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5434:1: ( rule__QualifiedNameWithBinding__RemainingAssignment_2_1 )

+            {

+             before(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingAssignment_2_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5435:1: ( rule__QualifiedNameWithBinding__RemainingAssignment_2_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5435:2: rule__QualifiedNameWithBinding__RemainingAssignment_2_1

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameWithBinding__RemainingAssignment_2_1_in_rule__QualifiedNameWithBinding__Group_2__1__Impl11691);

+            rule__QualifiedNameWithBinding__RemainingAssignment_2_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingAssignment_2_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameWithBinding__Group_2__1__Impl"

+

+

+    // $ANTLR start "rule__Tuple__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5449:1: rule__Tuple__Group__0 : rule__Tuple__Group__0__Impl rule__Tuple__Group__1 ;

+    public final void rule__Tuple__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5453:1: ( rule__Tuple__Group__0__Impl rule__Tuple__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5454:2: rule__Tuple__Group__0__Impl rule__Tuple__Group__1

+            {

+            pushFollow(FOLLOW_rule__Tuple__Group__0__Impl_in_rule__Tuple__Group__011725);

+            rule__Tuple__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Tuple__Group__1_in_rule__Tuple__Group__011728);

+            rule__Tuple__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group__0"

+

+

+    // $ANTLR start "rule__Tuple__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5461:1: rule__Tuple__Group__0__Impl : ( () ) ;

+    public final void rule__Tuple__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5465:1: ( ( () ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5466:1: ( () )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5466:1: ( () )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5467:1: ()

+            {

+             before(grammarAccess.getTupleAccess().getTupleAction_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5468:1: ()

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5470:1: 

+            {

+            }

+

+             after(grammarAccess.getTupleAccess().getTupleAction_0()); 

+

+            }

+

+

+            }

+

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group__0__Impl"

+

+

+    // $ANTLR start "rule__Tuple__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5480:1: rule__Tuple__Group__1 : rule__Tuple__Group__1__Impl rule__Tuple__Group__2 ;

+    public final void rule__Tuple__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5484:1: ( rule__Tuple__Group__1__Impl rule__Tuple__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5485:2: rule__Tuple__Group__1__Impl rule__Tuple__Group__2

+            {

+            pushFollow(FOLLOW_rule__Tuple__Group__1__Impl_in_rule__Tuple__Group__111786);

+            rule__Tuple__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Tuple__Group__2_in_rule__Tuple__Group__111789);

+            rule__Tuple__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group__1"

+

+

+    // $ANTLR start "rule__Tuple__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5492:1: rule__Tuple__Group__1__Impl : ( '(' ) ;

+    public final void rule__Tuple__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5496:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5497:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5497:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5498:1: '('

+            {

+             before(grammarAccess.getTupleAccess().getLeftParenthesisKeyword_1()); 

+            match(input,68,FOLLOW_68_in_rule__Tuple__Group__1__Impl11817); 

+             after(grammarAccess.getTupleAccess().getLeftParenthesisKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group__1__Impl"

+

+

+    // $ANTLR start "rule__Tuple__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5511:1: rule__Tuple__Group__2 : rule__Tuple__Group__2__Impl rule__Tuple__Group__3 ;

+    public final void rule__Tuple__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5515:1: ( rule__Tuple__Group__2__Impl rule__Tuple__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5516:2: rule__Tuple__Group__2__Impl rule__Tuple__Group__3

+            {

+            pushFollow(FOLLOW_rule__Tuple__Group__2__Impl_in_rule__Tuple__Group__211848);

+            rule__Tuple__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Tuple__Group__3_in_rule__Tuple__Group__211851);

+            rule__Tuple__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group__2"

+

+

+    // $ANTLR start "rule__Tuple__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5523:1: rule__Tuple__Group__2__Impl : ( ( rule__Tuple__Group_2__0 )? ) ;

+    public final void rule__Tuple__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5527:1: ( ( ( rule__Tuple__Group_2__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5528:1: ( ( rule__Tuple__Group_2__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5528:1: ( ( rule__Tuple__Group_2__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5529:1: ( rule__Tuple__Group_2__0 )?

+            {

+             before(grammarAccess.getTupleAccess().getGroup_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5530:1: ( rule__Tuple__Group_2__0 )?

+            int alt52=2;

+            int LA52_0 = input.LA(1);

+

+            if ( ((LA52_0>=RULE_INTEGERVALUE && LA52_0<=RULE_ID)||(LA52_0>=12 && LA52_0<=13)||(LA52_0>=25 && LA52_0<=27)||(LA52_0>=30 && LA52_0<=34)||LA52_0==68||(LA52_0>=83 && LA52_0<=86)) ) {

+                alt52=1;

+            }

+            switch (alt52) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5530:2: rule__Tuple__Group_2__0

+                    {

+                    pushFollow(FOLLOW_rule__Tuple__Group_2__0_in_rule__Tuple__Group__2__Impl11878);

+                    rule__Tuple__Group_2__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getTupleAccess().getGroup_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group__2__Impl"

+

+

+    // $ANTLR start "rule__Tuple__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5540:1: rule__Tuple__Group__3 : rule__Tuple__Group__3__Impl ;

+    public final void rule__Tuple__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5544:1: ( rule__Tuple__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5545:2: rule__Tuple__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__Tuple__Group__3__Impl_in_rule__Tuple__Group__311909);

+            rule__Tuple__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group__3"

+

+

+    // $ANTLR start "rule__Tuple__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5551:1: rule__Tuple__Group__3__Impl : ( ')' ) ;

+    public final void rule__Tuple__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5555:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5556:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5556:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5557:1: ')'

+            {

+             before(grammarAccess.getTupleAccess().getRightParenthesisKeyword_3()); 

+            match(input,69,FOLLOW_69_in_rule__Tuple__Group__3__Impl11937); 

+             after(grammarAccess.getTupleAccess().getRightParenthesisKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group__3__Impl"

+

+

+    // $ANTLR start "rule__Tuple__Group_2__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5578:1: rule__Tuple__Group_2__0 : rule__Tuple__Group_2__0__Impl rule__Tuple__Group_2__1 ;

+    public final void rule__Tuple__Group_2__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5582:1: ( rule__Tuple__Group_2__0__Impl rule__Tuple__Group_2__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5583:2: rule__Tuple__Group_2__0__Impl rule__Tuple__Group_2__1

+            {

+            pushFollow(FOLLOW_rule__Tuple__Group_2__0__Impl_in_rule__Tuple__Group_2__011976);

+            rule__Tuple__Group_2__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Tuple__Group_2__1_in_rule__Tuple__Group_2__011979);

+            rule__Tuple__Group_2__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group_2__0"

+

+

+    // $ANTLR start "rule__Tuple__Group_2__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5590:1: rule__Tuple__Group_2__0__Impl : ( ( rule__Tuple__TupleElementsAssignment_2_0 ) ) ;

+    public final void rule__Tuple__Group_2__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5594:1: ( ( ( rule__Tuple__TupleElementsAssignment_2_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5595:1: ( ( rule__Tuple__TupleElementsAssignment_2_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5595:1: ( ( rule__Tuple__TupleElementsAssignment_2_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5596:1: ( rule__Tuple__TupleElementsAssignment_2_0 )

+            {

+             before(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5597:1: ( rule__Tuple__TupleElementsAssignment_2_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5597:2: rule__Tuple__TupleElementsAssignment_2_0

+            {

+            pushFollow(FOLLOW_rule__Tuple__TupleElementsAssignment_2_0_in_rule__Tuple__Group_2__0__Impl12006);

+            rule__Tuple__TupleElementsAssignment_2_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group_2__0__Impl"

+

+

+    // $ANTLR start "rule__Tuple__Group_2__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5607:1: rule__Tuple__Group_2__1 : rule__Tuple__Group_2__1__Impl ;

+    public final void rule__Tuple__Group_2__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5611:1: ( rule__Tuple__Group_2__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5612:2: rule__Tuple__Group_2__1__Impl

+            {

+            pushFollow(FOLLOW_rule__Tuple__Group_2__1__Impl_in_rule__Tuple__Group_2__112036);

+            rule__Tuple__Group_2__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group_2__1"

+

+

+    // $ANTLR start "rule__Tuple__Group_2__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5618:1: rule__Tuple__Group_2__1__Impl : ( ( rule__Tuple__Group_2_1__0 )* ) ;

+    public final void rule__Tuple__Group_2__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5622:1: ( ( ( rule__Tuple__Group_2_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5623:1: ( ( rule__Tuple__Group_2_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5623:1: ( ( rule__Tuple__Group_2_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5624:1: ( rule__Tuple__Group_2_1__0 )*

+            {

+             before(grammarAccess.getTupleAccess().getGroup_2_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5625:1: ( rule__Tuple__Group_2_1__0 )*

+            loop53:

+            do {

+                int alt53=2;

+                int LA53_0 = input.LA(1);

+

+                if ( (LA53_0==66) ) {

+                    alt53=1;

+                }

+

+

+                switch (alt53) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5625:2: rule__Tuple__Group_2_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__Tuple__Group_2_1__0_in_rule__Tuple__Group_2__1__Impl12063);

+            	    rule__Tuple__Group_2_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop53;

+                }

+            } while (true);

+

+             after(grammarAccess.getTupleAccess().getGroup_2_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group_2__1__Impl"

+

+

+    // $ANTLR start "rule__Tuple__Group_2_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5639:1: rule__Tuple__Group_2_1__0 : rule__Tuple__Group_2_1__0__Impl rule__Tuple__Group_2_1__1 ;

+    public final void rule__Tuple__Group_2_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5643:1: ( rule__Tuple__Group_2_1__0__Impl rule__Tuple__Group_2_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5644:2: rule__Tuple__Group_2_1__0__Impl rule__Tuple__Group_2_1__1

+            {

+            pushFollow(FOLLOW_rule__Tuple__Group_2_1__0__Impl_in_rule__Tuple__Group_2_1__012098);

+            rule__Tuple__Group_2_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Tuple__Group_2_1__1_in_rule__Tuple__Group_2_1__012101);

+            rule__Tuple__Group_2_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group_2_1__0"

+

+

+    // $ANTLR start "rule__Tuple__Group_2_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5651:1: rule__Tuple__Group_2_1__0__Impl : ( ',' ) ;

+    public final void rule__Tuple__Group_2_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5655:1: ( ( ',' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5656:1: ( ',' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5656:1: ( ',' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5657:1: ','

+            {

+             before(grammarAccess.getTupleAccess().getCommaKeyword_2_1_0()); 

+            match(input,66,FOLLOW_66_in_rule__Tuple__Group_2_1__0__Impl12129); 

+             after(grammarAccess.getTupleAccess().getCommaKeyword_2_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group_2_1__0__Impl"

+

+

+    // $ANTLR start "rule__Tuple__Group_2_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5670:1: rule__Tuple__Group_2_1__1 : rule__Tuple__Group_2_1__1__Impl ;

+    public final void rule__Tuple__Group_2_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5674:1: ( rule__Tuple__Group_2_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5675:2: rule__Tuple__Group_2_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__Tuple__Group_2_1__1__Impl_in_rule__Tuple__Group_2_1__112160);

+            rule__Tuple__Group_2_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group_2_1__1"

+

+

+    // $ANTLR start "rule__Tuple__Group_2_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5681:1: rule__Tuple__Group_2_1__1__Impl : ( ( rule__Tuple__TupleElementsAssignment_2_1_1 ) ) ;

+    public final void rule__Tuple__Group_2_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5685:1: ( ( ( rule__Tuple__TupleElementsAssignment_2_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5686:1: ( ( rule__Tuple__TupleElementsAssignment_2_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5686:1: ( ( rule__Tuple__TupleElementsAssignment_2_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5687:1: ( rule__Tuple__TupleElementsAssignment_2_1_1 )

+            {

+             before(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5688:1: ( rule__Tuple__TupleElementsAssignment_2_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5688:2: rule__Tuple__TupleElementsAssignment_2_1_1

+            {

+            pushFollow(FOLLOW_rule__Tuple__TupleElementsAssignment_2_1_1_in_rule__Tuple__Group_2_1__1__Impl12187);

+            rule__Tuple__TupleElementsAssignment_2_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getTupleAccess().getTupleElementsAssignment_2_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__Group_2_1__1__Impl"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5702:1: rule__ConditionalTestExpression__Group__0 : rule__ConditionalTestExpression__Group__0__Impl rule__ConditionalTestExpression__Group__1 ;

+    public final void rule__ConditionalTestExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5706:1: ( rule__ConditionalTestExpression__Group__0__Impl rule__ConditionalTestExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5707:2: rule__ConditionalTestExpression__Group__0__Impl rule__ConditionalTestExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__Group__0__Impl_in_rule__ConditionalTestExpression__Group__012221);

+            rule__ConditionalTestExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__Group__1_in_rule__ConditionalTestExpression__Group__012224);

+            rule__ConditionalTestExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__Group__0"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5714:1: rule__ConditionalTestExpression__Group__0__Impl : ( ( rule__ConditionalTestExpression__ExpAssignment_0 ) ) ;

+    public final void rule__ConditionalTestExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5718:1: ( ( ( rule__ConditionalTestExpression__ExpAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5719:1: ( ( rule__ConditionalTestExpression__ExpAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5719:1: ( ( rule__ConditionalTestExpression__ExpAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5720:1: ( rule__ConditionalTestExpression__ExpAssignment_0 )

+            {

+             before(grammarAccess.getConditionalTestExpressionAccess().getExpAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5721:1: ( rule__ConditionalTestExpression__ExpAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5721:2: rule__ConditionalTestExpression__ExpAssignment_0

+            {

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__ExpAssignment_0_in_rule__ConditionalTestExpression__Group__0__Impl12251);

+            rule__ConditionalTestExpression__ExpAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getConditionalTestExpressionAccess().getExpAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5731:1: rule__ConditionalTestExpression__Group__1 : rule__ConditionalTestExpression__Group__1__Impl ;

+    public final void rule__ConditionalTestExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5735:1: ( rule__ConditionalTestExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5736:2: rule__ConditionalTestExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__Group__1__Impl_in_rule__ConditionalTestExpression__Group__112281);

+            rule__ConditionalTestExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__Group__1"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5742:1: rule__ConditionalTestExpression__Group__1__Impl : ( ( rule__ConditionalTestExpression__Group_1__0 )? ) ;

+    public final void rule__ConditionalTestExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5746:1: ( ( ( rule__ConditionalTestExpression__Group_1__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5747:1: ( ( rule__ConditionalTestExpression__Group_1__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5747:1: ( ( rule__ConditionalTestExpression__Group_1__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5748:1: ( rule__ConditionalTestExpression__Group_1__0 )?

+            {

+             before(grammarAccess.getConditionalTestExpressionAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5749:1: ( rule__ConditionalTestExpression__Group_1__0 )?

+            int alt54=2;

+            int LA54_0 = input.LA(1);

+

+            if ( (LA54_0==70) ) {

+                alt54=1;

+            }

+            switch (alt54) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5749:2: rule__ConditionalTestExpression__Group_1__0

+                    {

+                    pushFollow(FOLLOW_rule__ConditionalTestExpression__Group_1__0_in_rule__ConditionalTestExpression__Group__1__Impl12308);

+                    rule__ConditionalTestExpression__Group_1__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getConditionalTestExpressionAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5763:1: rule__ConditionalTestExpression__Group_1__0 : rule__ConditionalTestExpression__Group_1__0__Impl rule__ConditionalTestExpression__Group_1__1 ;

+    public final void rule__ConditionalTestExpression__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5767:1: ( rule__ConditionalTestExpression__Group_1__0__Impl rule__ConditionalTestExpression__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5768:2: rule__ConditionalTestExpression__Group_1__0__Impl rule__ConditionalTestExpression__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__Group_1__0__Impl_in_rule__ConditionalTestExpression__Group_1__012343);

+            rule__ConditionalTestExpression__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__Group_1__1_in_rule__ConditionalTestExpression__Group_1__012346);

+            rule__ConditionalTestExpression__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__Group_1__0"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5775:1: rule__ConditionalTestExpression__Group_1__0__Impl : ( '?' ) ;

+    public final void rule__ConditionalTestExpression__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5779:1: ( ( '?' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5780:1: ( '?' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5780:1: ( '?' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5781:1: '?'

+            {

+             before(grammarAccess.getConditionalTestExpressionAccess().getQuestionMarkKeyword_1_0()); 

+            match(input,70,FOLLOW_70_in_rule__ConditionalTestExpression__Group_1__0__Impl12374); 

+             after(grammarAccess.getConditionalTestExpressionAccess().getQuestionMarkKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5794:1: rule__ConditionalTestExpression__Group_1__1 : rule__ConditionalTestExpression__Group_1__1__Impl rule__ConditionalTestExpression__Group_1__2 ;

+    public final void rule__ConditionalTestExpression__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5798:1: ( rule__ConditionalTestExpression__Group_1__1__Impl rule__ConditionalTestExpression__Group_1__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5799:2: rule__ConditionalTestExpression__Group_1__1__Impl rule__ConditionalTestExpression__Group_1__2

+            {

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__Group_1__1__Impl_in_rule__ConditionalTestExpression__Group_1__112405);

+            rule__ConditionalTestExpression__Group_1__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__Group_1__2_in_rule__ConditionalTestExpression__Group_1__112408);

+            rule__ConditionalTestExpression__Group_1__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__Group_1__1"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5806:1: rule__ConditionalTestExpression__Group_1__1__Impl : ( ( rule__ConditionalTestExpression__WhenTrueAssignment_1_1 ) ) ;

+    public final void rule__ConditionalTestExpression__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5810:1: ( ( ( rule__ConditionalTestExpression__WhenTrueAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5811:1: ( ( rule__ConditionalTestExpression__WhenTrueAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5811:1: ( ( rule__ConditionalTestExpression__WhenTrueAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5812:1: ( rule__ConditionalTestExpression__WhenTrueAssignment_1_1 )

+            {

+             before(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5813:1: ( rule__ConditionalTestExpression__WhenTrueAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5813:2: rule__ConditionalTestExpression__WhenTrueAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__WhenTrueAssignment_1_1_in_rule__ConditionalTestExpression__Group_1__1__Impl12435);

+            rule__ConditionalTestExpression__WhenTrueAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__Group_1__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5823:1: rule__ConditionalTestExpression__Group_1__2 : rule__ConditionalTestExpression__Group_1__2__Impl rule__ConditionalTestExpression__Group_1__3 ;

+    public final void rule__ConditionalTestExpression__Group_1__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5827:1: ( rule__ConditionalTestExpression__Group_1__2__Impl rule__ConditionalTestExpression__Group_1__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5828:2: rule__ConditionalTestExpression__Group_1__2__Impl rule__ConditionalTestExpression__Group_1__3

+            {

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__Group_1__2__Impl_in_rule__ConditionalTestExpression__Group_1__212465);

+            rule__ConditionalTestExpression__Group_1__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__Group_1__3_in_rule__ConditionalTestExpression__Group_1__212468);

+            rule__ConditionalTestExpression__Group_1__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__Group_1__2"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__Group_1__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5835:1: rule__ConditionalTestExpression__Group_1__2__Impl : ( ':' ) ;

+    public final void rule__ConditionalTestExpression__Group_1__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5839:1: ( ( ':' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5840:1: ( ':' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5840:1: ( ':' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5841:1: ':'

+            {

+             before(grammarAccess.getConditionalTestExpressionAccess().getColonKeyword_1_2()); 

+            match(input,71,FOLLOW_71_in_rule__ConditionalTestExpression__Group_1__2__Impl12496); 

+             after(grammarAccess.getConditionalTestExpressionAccess().getColonKeyword_1_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__Group_1__2__Impl"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__Group_1__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5854:1: rule__ConditionalTestExpression__Group_1__3 : rule__ConditionalTestExpression__Group_1__3__Impl ;

+    public final void rule__ConditionalTestExpression__Group_1__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5858:1: ( rule__ConditionalTestExpression__Group_1__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5859:2: rule__ConditionalTestExpression__Group_1__3__Impl

+            {

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__Group_1__3__Impl_in_rule__ConditionalTestExpression__Group_1__312527);

+            rule__ConditionalTestExpression__Group_1__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__Group_1__3"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__Group_1__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5865:1: rule__ConditionalTestExpression__Group_1__3__Impl : ( ( rule__ConditionalTestExpression__WhenFalseAssignment_1_3 ) ) ;

+    public final void rule__ConditionalTestExpression__Group_1__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5869:1: ( ( ( rule__ConditionalTestExpression__WhenFalseAssignment_1_3 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5870:1: ( ( rule__ConditionalTestExpression__WhenFalseAssignment_1_3 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5870:1: ( ( rule__ConditionalTestExpression__WhenFalseAssignment_1_3 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5871:1: ( rule__ConditionalTestExpression__WhenFalseAssignment_1_3 )

+            {

+             before(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseAssignment_1_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5872:1: ( rule__ConditionalTestExpression__WhenFalseAssignment_1_3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5872:2: rule__ConditionalTestExpression__WhenFalseAssignment_1_3

+            {

+            pushFollow(FOLLOW_rule__ConditionalTestExpression__WhenFalseAssignment_1_3_in_rule__ConditionalTestExpression__Group_1__3__Impl12554);

+            rule__ConditionalTestExpression__WhenFalseAssignment_1_3();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseAssignment_1_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__Group_1__3__Impl"

+

+

+    // $ANTLR start "rule__ConditionalOrExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5890:1: rule__ConditionalOrExpression__Group__0 : rule__ConditionalOrExpression__Group__0__Impl rule__ConditionalOrExpression__Group__1 ;

+    public final void rule__ConditionalOrExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5894:1: ( rule__ConditionalOrExpression__Group__0__Impl rule__ConditionalOrExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5895:2: rule__ConditionalOrExpression__Group__0__Impl rule__ConditionalOrExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__ConditionalOrExpression__Group__0__Impl_in_rule__ConditionalOrExpression__Group__012592);

+            rule__ConditionalOrExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ConditionalOrExpression__Group__1_in_rule__ConditionalOrExpression__Group__012595);

+            rule__ConditionalOrExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalOrExpression__Group__0"

+

+

+    // $ANTLR start "rule__ConditionalOrExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5902:1: rule__ConditionalOrExpression__Group__0__Impl : ( ( rule__ConditionalOrExpression__ExpAssignment_0 ) ) ;

+    public final void rule__ConditionalOrExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5906:1: ( ( ( rule__ConditionalOrExpression__ExpAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5907:1: ( ( rule__ConditionalOrExpression__ExpAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5907:1: ( ( rule__ConditionalOrExpression__ExpAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5908:1: ( rule__ConditionalOrExpression__ExpAssignment_0 )

+            {

+             before(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5909:1: ( rule__ConditionalOrExpression__ExpAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5909:2: rule__ConditionalOrExpression__ExpAssignment_0

+            {

+            pushFollow(FOLLOW_rule__ConditionalOrExpression__ExpAssignment_0_in_rule__ConditionalOrExpression__Group__0__Impl12622);

+            rule__ConditionalOrExpression__ExpAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalOrExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ConditionalOrExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5919:1: rule__ConditionalOrExpression__Group__1 : rule__ConditionalOrExpression__Group__1__Impl ;

+    public final void rule__ConditionalOrExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5923:1: ( rule__ConditionalOrExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5924:2: rule__ConditionalOrExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ConditionalOrExpression__Group__1__Impl_in_rule__ConditionalOrExpression__Group__112652);

+            rule__ConditionalOrExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalOrExpression__Group__1"

+

+

+    // $ANTLR start "rule__ConditionalOrExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5930:1: rule__ConditionalOrExpression__Group__1__Impl : ( ( rule__ConditionalOrExpression__Group_1__0 )* ) ;

+    public final void rule__ConditionalOrExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5934:1: ( ( ( rule__ConditionalOrExpression__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5935:1: ( ( rule__ConditionalOrExpression__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5935:1: ( ( rule__ConditionalOrExpression__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5936:1: ( rule__ConditionalOrExpression__Group_1__0 )*

+            {

+             before(grammarAccess.getConditionalOrExpressionAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5937:1: ( rule__ConditionalOrExpression__Group_1__0 )*

+            loop55:

+            do {

+                int alt55=2;

+                int LA55_0 = input.LA(1);

+

+                if ( (LA55_0==72) ) {

+                    alt55=1;

+                }

+

+

+                switch (alt55) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5937:2: rule__ConditionalOrExpression__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__ConditionalOrExpression__Group_1__0_in_rule__ConditionalOrExpression__Group__1__Impl12679);

+            	    rule__ConditionalOrExpression__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop55;

+                }

+            } while (true);

+

+             after(grammarAccess.getConditionalOrExpressionAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalOrExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ConditionalOrExpression__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5951:1: rule__ConditionalOrExpression__Group_1__0 : rule__ConditionalOrExpression__Group_1__0__Impl rule__ConditionalOrExpression__Group_1__1 ;

+    public final void rule__ConditionalOrExpression__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5955:1: ( rule__ConditionalOrExpression__Group_1__0__Impl rule__ConditionalOrExpression__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5956:2: rule__ConditionalOrExpression__Group_1__0__Impl rule__ConditionalOrExpression__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__ConditionalOrExpression__Group_1__0__Impl_in_rule__ConditionalOrExpression__Group_1__012714);

+            rule__ConditionalOrExpression__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ConditionalOrExpression__Group_1__1_in_rule__ConditionalOrExpression__Group_1__012717);

+            rule__ConditionalOrExpression__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalOrExpression__Group_1__0"

+

+

+    // $ANTLR start "rule__ConditionalOrExpression__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5963:1: rule__ConditionalOrExpression__Group_1__0__Impl : ( '||' ) ;

+    public final void rule__ConditionalOrExpression__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5967:1: ( ( '||' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5968:1: ( '||' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5968:1: ( '||' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5969:1: '||'

+            {

+             before(grammarAccess.getConditionalOrExpressionAccess().getVerticalLineVerticalLineKeyword_1_0()); 

+            match(input,72,FOLLOW_72_in_rule__ConditionalOrExpression__Group_1__0__Impl12745); 

+             after(grammarAccess.getConditionalOrExpressionAccess().getVerticalLineVerticalLineKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalOrExpression__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__ConditionalOrExpression__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5982:1: rule__ConditionalOrExpression__Group_1__1 : rule__ConditionalOrExpression__Group_1__1__Impl ;

+    public final void rule__ConditionalOrExpression__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5986:1: ( rule__ConditionalOrExpression__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5987:2: rule__ConditionalOrExpression__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ConditionalOrExpression__Group_1__1__Impl_in_rule__ConditionalOrExpression__Group_1__112776);

+            rule__ConditionalOrExpression__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalOrExpression__Group_1__1"

+

+

+    // $ANTLR start "rule__ConditionalOrExpression__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5993:1: rule__ConditionalOrExpression__Group_1__1__Impl : ( ( rule__ConditionalOrExpression__ExpAssignment_1_1 ) ) ;

+    public final void rule__ConditionalOrExpression__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5997:1: ( ( ( rule__ConditionalOrExpression__ExpAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5998:1: ( ( rule__ConditionalOrExpression__ExpAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5998:1: ( ( rule__ConditionalOrExpression__ExpAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:5999:1: ( rule__ConditionalOrExpression__ExpAssignment_1_1 )

+            {

+             before(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6000:1: ( rule__ConditionalOrExpression__ExpAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6000:2: rule__ConditionalOrExpression__ExpAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__ConditionalOrExpression__ExpAssignment_1_1_in_rule__ConditionalOrExpression__Group_1__1__Impl12803);

+            rule__ConditionalOrExpression__ExpAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getConditionalOrExpressionAccess().getExpAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalOrExpression__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__ConditionalAndExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6014:1: rule__ConditionalAndExpression__Group__0 : rule__ConditionalAndExpression__Group__0__Impl rule__ConditionalAndExpression__Group__1 ;

+    public final void rule__ConditionalAndExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6018:1: ( rule__ConditionalAndExpression__Group__0__Impl rule__ConditionalAndExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6019:2: rule__ConditionalAndExpression__Group__0__Impl rule__ConditionalAndExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__ConditionalAndExpression__Group__0__Impl_in_rule__ConditionalAndExpression__Group__012837);

+            rule__ConditionalAndExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ConditionalAndExpression__Group__1_in_rule__ConditionalAndExpression__Group__012840);

+            rule__ConditionalAndExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalAndExpression__Group__0"

+

+

+    // $ANTLR start "rule__ConditionalAndExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6026:1: rule__ConditionalAndExpression__Group__0__Impl : ( ( rule__ConditionalAndExpression__ExpAssignment_0 ) ) ;

+    public final void rule__ConditionalAndExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6030:1: ( ( ( rule__ConditionalAndExpression__ExpAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6031:1: ( ( rule__ConditionalAndExpression__ExpAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6031:1: ( ( rule__ConditionalAndExpression__ExpAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6032:1: ( rule__ConditionalAndExpression__ExpAssignment_0 )

+            {

+             before(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6033:1: ( rule__ConditionalAndExpression__ExpAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6033:2: rule__ConditionalAndExpression__ExpAssignment_0

+            {

+            pushFollow(FOLLOW_rule__ConditionalAndExpression__ExpAssignment_0_in_rule__ConditionalAndExpression__Group__0__Impl12867);

+            rule__ConditionalAndExpression__ExpAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalAndExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ConditionalAndExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6043:1: rule__ConditionalAndExpression__Group__1 : rule__ConditionalAndExpression__Group__1__Impl ;

+    public final void rule__ConditionalAndExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6047:1: ( rule__ConditionalAndExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6048:2: rule__ConditionalAndExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ConditionalAndExpression__Group__1__Impl_in_rule__ConditionalAndExpression__Group__112897);

+            rule__ConditionalAndExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalAndExpression__Group__1"

+

+

+    // $ANTLR start "rule__ConditionalAndExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6054:1: rule__ConditionalAndExpression__Group__1__Impl : ( ( rule__ConditionalAndExpression__Group_1__0 )* ) ;

+    public final void rule__ConditionalAndExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6058:1: ( ( ( rule__ConditionalAndExpression__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6059:1: ( ( rule__ConditionalAndExpression__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6059:1: ( ( rule__ConditionalAndExpression__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6060:1: ( rule__ConditionalAndExpression__Group_1__0 )*

+            {

+             before(grammarAccess.getConditionalAndExpressionAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6061:1: ( rule__ConditionalAndExpression__Group_1__0 )*

+            loop56:

+            do {

+                int alt56=2;

+                int LA56_0 = input.LA(1);

+

+                if ( (LA56_0==73) ) {

+                    alt56=1;

+                }

+

+

+                switch (alt56) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6061:2: rule__ConditionalAndExpression__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__ConditionalAndExpression__Group_1__0_in_rule__ConditionalAndExpression__Group__1__Impl12924);

+            	    rule__ConditionalAndExpression__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop56;

+                }

+            } while (true);

+

+             after(grammarAccess.getConditionalAndExpressionAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalAndExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ConditionalAndExpression__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6075:1: rule__ConditionalAndExpression__Group_1__0 : rule__ConditionalAndExpression__Group_1__0__Impl rule__ConditionalAndExpression__Group_1__1 ;

+    public final void rule__ConditionalAndExpression__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6079:1: ( rule__ConditionalAndExpression__Group_1__0__Impl rule__ConditionalAndExpression__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6080:2: rule__ConditionalAndExpression__Group_1__0__Impl rule__ConditionalAndExpression__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__ConditionalAndExpression__Group_1__0__Impl_in_rule__ConditionalAndExpression__Group_1__012959);

+            rule__ConditionalAndExpression__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ConditionalAndExpression__Group_1__1_in_rule__ConditionalAndExpression__Group_1__012962);

+            rule__ConditionalAndExpression__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalAndExpression__Group_1__0"

+

+

+    // $ANTLR start "rule__ConditionalAndExpression__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6087:1: rule__ConditionalAndExpression__Group_1__0__Impl : ( '&&' ) ;

+    public final void rule__ConditionalAndExpression__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6091:1: ( ( '&&' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6092:1: ( '&&' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6092:1: ( '&&' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6093:1: '&&'

+            {

+             before(grammarAccess.getConditionalAndExpressionAccess().getAmpersandAmpersandKeyword_1_0()); 

+            match(input,73,FOLLOW_73_in_rule__ConditionalAndExpression__Group_1__0__Impl12990); 

+             after(grammarAccess.getConditionalAndExpressionAccess().getAmpersandAmpersandKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalAndExpression__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__ConditionalAndExpression__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6106:1: rule__ConditionalAndExpression__Group_1__1 : rule__ConditionalAndExpression__Group_1__1__Impl ;

+    public final void rule__ConditionalAndExpression__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6110:1: ( rule__ConditionalAndExpression__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6111:2: rule__ConditionalAndExpression__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ConditionalAndExpression__Group_1__1__Impl_in_rule__ConditionalAndExpression__Group_1__113021);

+            rule__ConditionalAndExpression__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalAndExpression__Group_1__1"

+

+

+    // $ANTLR start "rule__ConditionalAndExpression__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6117:1: rule__ConditionalAndExpression__Group_1__1__Impl : ( ( rule__ConditionalAndExpression__ExpAssignment_1_1 ) ) ;

+    public final void rule__ConditionalAndExpression__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6121:1: ( ( ( rule__ConditionalAndExpression__ExpAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6122:1: ( ( rule__ConditionalAndExpression__ExpAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6122:1: ( ( rule__ConditionalAndExpression__ExpAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6123:1: ( rule__ConditionalAndExpression__ExpAssignment_1_1 )

+            {

+             before(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6124:1: ( rule__ConditionalAndExpression__ExpAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6124:2: rule__ConditionalAndExpression__ExpAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__ConditionalAndExpression__ExpAssignment_1_1_in_rule__ConditionalAndExpression__Group_1__1__Impl13048);

+            rule__ConditionalAndExpression__ExpAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getConditionalAndExpressionAccess().getExpAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalAndExpression__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__InclusiveOrExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6138:1: rule__InclusiveOrExpression__Group__0 : rule__InclusiveOrExpression__Group__0__Impl rule__InclusiveOrExpression__Group__1 ;

+    public final void rule__InclusiveOrExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6142:1: ( rule__InclusiveOrExpression__Group__0__Impl rule__InclusiveOrExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6143:2: rule__InclusiveOrExpression__Group__0__Impl rule__InclusiveOrExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__InclusiveOrExpression__Group__0__Impl_in_rule__InclusiveOrExpression__Group__013082);

+            rule__InclusiveOrExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InclusiveOrExpression__Group__1_in_rule__InclusiveOrExpression__Group__013085);

+            rule__InclusiveOrExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InclusiveOrExpression__Group__0"

+

+

+    // $ANTLR start "rule__InclusiveOrExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6150:1: rule__InclusiveOrExpression__Group__0__Impl : ( ( rule__InclusiveOrExpression__ExpAssignment_0 ) ) ;

+    public final void rule__InclusiveOrExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6154:1: ( ( ( rule__InclusiveOrExpression__ExpAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6155:1: ( ( rule__InclusiveOrExpression__ExpAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6155:1: ( ( rule__InclusiveOrExpression__ExpAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6156:1: ( rule__InclusiveOrExpression__ExpAssignment_0 )

+            {

+             before(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6157:1: ( rule__InclusiveOrExpression__ExpAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6157:2: rule__InclusiveOrExpression__ExpAssignment_0

+            {

+            pushFollow(FOLLOW_rule__InclusiveOrExpression__ExpAssignment_0_in_rule__InclusiveOrExpression__Group__0__Impl13112);

+            rule__InclusiveOrExpression__ExpAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InclusiveOrExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__InclusiveOrExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6167:1: rule__InclusiveOrExpression__Group__1 : rule__InclusiveOrExpression__Group__1__Impl ;

+    public final void rule__InclusiveOrExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6171:1: ( rule__InclusiveOrExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6172:2: rule__InclusiveOrExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__InclusiveOrExpression__Group__1__Impl_in_rule__InclusiveOrExpression__Group__113142);

+            rule__InclusiveOrExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InclusiveOrExpression__Group__1"

+

+

+    // $ANTLR start "rule__InclusiveOrExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6178:1: rule__InclusiveOrExpression__Group__1__Impl : ( ( rule__InclusiveOrExpression__Group_1__0 )* ) ;

+    public final void rule__InclusiveOrExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6182:1: ( ( ( rule__InclusiveOrExpression__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6183:1: ( ( rule__InclusiveOrExpression__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6183:1: ( ( rule__InclusiveOrExpression__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6184:1: ( rule__InclusiveOrExpression__Group_1__0 )*

+            {

+             before(grammarAccess.getInclusiveOrExpressionAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6185:1: ( rule__InclusiveOrExpression__Group_1__0 )*

+            loop57:

+            do {

+                int alt57=2;

+                int LA57_0 = input.LA(1);

+

+                if ( (LA57_0==74) ) {

+                    alt57=1;

+                }

+

+

+                switch (alt57) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6185:2: rule__InclusiveOrExpression__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__InclusiveOrExpression__Group_1__0_in_rule__InclusiveOrExpression__Group__1__Impl13169);

+            	    rule__InclusiveOrExpression__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop57;

+                }

+            } while (true);

+

+             after(grammarAccess.getInclusiveOrExpressionAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InclusiveOrExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__InclusiveOrExpression__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6199:1: rule__InclusiveOrExpression__Group_1__0 : rule__InclusiveOrExpression__Group_1__0__Impl rule__InclusiveOrExpression__Group_1__1 ;

+    public final void rule__InclusiveOrExpression__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6203:1: ( rule__InclusiveOrExpression__Group_1__0__Impl rule__InclusiveOrExpression__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6204:2: rule__InclusiveOrExpression__Group_1__0__Impl rule__InclusiveOrExpression__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__InclusiveOrExpression__Group_1__0__Impl_in_rule__InclusiveOrExpression__Group_1__013204);

+            rule__InclusiveOrExpression__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InclusiveOrExpression__Group_1__1_in_rule__InclusiveOrExpression__Group_1__013207);

+            rule__InclusiveOrExpression__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InclusiveOrExpression__Group_1__0"

+

+

+    // $ANTLR start "rule__InclusiveOrExpression__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6211:1: rule__InclusiveOrExpression__Group_1__0__Impl : ( '|' ) ;

+    public final void rule__InclusiveOrExpression__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6215:1: ( ( '|' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6216:1: ( '|' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6216:1: ( '|' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6217:1: '|'

+            {

+             before(grammarAccess.getInclusiveOrExpressionAccess().getVerticalLineKeyword_1_0()); 

+            match(input,74,FOLLOW_74_in_rule__InclusiveOrExpression__Group_1__0__Impl13235); 

+             after(grammarAccess.getInclusiveOrExpressionAccess().getVerticalLineKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InclusiveOrExpression__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__InclusiveOrExpression__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6230:1: rule__InclusiveOrExpression__Group_1__1 : rule__InclusiveOrExpression__Group_1__1__Impl ;

+    public final void rule__InclusiveOrExpression__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6234:1: ( rule__InclusiveOrExpression__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6235:2: rule__InclusiveOrExpression__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__InclusiveOrExpression__Group_1__1__Impl_in_rule__InclusiveOrExpression__Group_1__113266);

+            rule__InclusiveOrExpression__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InclusiveOrExpression__Group_1__1"

+

+

+    // $ANTLR start "rule__InclusiveOrExpression__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6241:1: rule__InclusiveOrExpression__Group_1__1__Impl : ( ( rule__InclusiveOrExpression__ExpAssignment_1_1 ) ) ;

+    public final void rule__InclusiveOrExpression__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6245:1: ( ( ( rule__InclusiveOrExpression__ExpAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6246:1: ( ( rule__InclusiveOrExpression__ExpAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6246:1: ( ( rule__InclusiveOrExpression__ExpAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6247:1: ( rule__InclusiveOrExpression__ExpAssignment_1_1 )

+            {

+             before(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6248:1: ( rule__InclusiveOrExpression__ExpAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6248:2: rule__InclusiveOrExpression__ExpAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__InclusiveOrExpression__ExpAssignment_1_1_in_rule__InclusiveOrExpression__Group_1__1__Impl13293);

+            rule__InclusiveOrExpression__ExpAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInclusiveOrExpressionAccess().getExpAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InclusiveOrExpression__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__ExclusiveOrExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6262:1: rule__ExclusiveOrExpression__Group__0 : rule__ExclusiveOrExpression__Group__0__Impl rule__ExclusiveOrExpression__Group__1 ;

+    public final void rule__ExclusiveOrExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6266:1: ( rule__ExclusiveOrExpression__Group__0__Impl rule__ExclusiveOrExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6267:2: rule__ExclusiveOrExpression__Group__0__Impl rule__ExclusiveOrExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__ExclusiveOrExpression__Group__0__Impl_in_rule__ExclusiveOrExpression__Group__013327);

+            rule__ExclusiveOrExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ExclusiveOrExpression__Group__1_in_rule__ExclusiveOrExpression__Group__013330);

+            rule__ExclusiveOrExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ExclusiveOrExpression__Group__0"

+

+

+    // $ANTLR start "rule__ExclusiveOrExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6274:1: rule__ExclusiveOrExpression__Group__0__Impl : ( ( rule__ExclusiveOrExpression__ExpAssignment_0 ) ) ;

+    public final void rule__ExclusiveOrExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6278:1: ( ( ( rule__ExclusiveOrExpression__ExpAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6279:1: ( ( rule__ExclusiveOrExpression__ExpAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6279:1: ( ( rule__ExclusiveOrExpression__ExpAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6280:1: ( rule__ExclusiveOrExpression__ExpAssignment_0 )

+            {

+             before(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6281:1: ( rule__ExclusiveOrExpression__ExpAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6281:2: rule__ExclusiveOrExpression__ExpAssignment_0

+            {

+            pushFollow(FOLLOW_rule__ExclusiveOrExpression__ExpAssignment_0_in_rule__ExclusiveOrExpression__Group__0__Impl13357);

+            rule__ExclusiveOrExpression__ExpAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ExclusiveOrExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ExclusiveOrExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6291:1: rule__ExclusiveOrExpression__Group__1 : rule__ExclusiveOrExpression__Group__1__Impl ;

+    public final void rule__ExclusiveOrExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6295:1: ( rule__ExclusiveOrExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6296:2: rule__ExclusiveOrExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ExclusiveOrExpression__Group__1__Impl_in_rule__ExclusiveOrExpression__Group__113387);

+            rule__ExclusiveOrExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ExclusiveOrExpression__Group__1"

+

+

+    // $ANTLR start "rule__ExclusiveOrExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6302:1: rule__ExclusiveOrExpression__Group__1__Impl : ( ( rule__ExclusiveOrExpression__Group_1__0 )* ) ;

+    public final void rule__ExclusiveOrExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6306:1: ( ( ( rule__ExclusiveOrExpression__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6307:1: ( ( rule__ExclusiveOrExpression__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6307:1: ( ( rule__ExclusiveOrExpression__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6308:1: ( rule__ExclusiveOrExpression__Group_1__0 )*

+            {

+             before(grammarAccess.getExclusiveOrExpressionAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6309:1: ( rule__ExclusiveOrExpression__Group_1__0 )*

+            loop58:

+            do {

+                int alt58=2;

+                int LA58_0 = input.LA(1);

+

+                if ( (LA58_0==75) ) {

+                    alt58=1;

+                }

+

+

+                switch (alt58) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6309:2: rule__ExclusiveOrExpression__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__ExclusiveOrExpression__Group_1__0_in_rule__ExclusiveOrExpression__Group__1__Impl13414);

+            	    rule__ExclusiveOrExpression__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop58;

+                }

+            } while (true);

+

+             after(grammarAccess.getExclusiveOrExpressionAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ExclusiveOrExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ExclusiveOrExpression__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6323:1: rule__ExclusiveOrExpression__Group_1__0 : rule__ExclusiveOrExpression__Group_1__0__Impl rule__ExclusiveOrExpression__Group_1__1 ;

+    public final void rule__ExclusiveOrExpression__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6327:1: ( rule__ExclusiveOrExpression__Group_1__0__Impl rule__ExclusiveOrExpression__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6328:2: rule__ExclusiveOrExpression__Group_1__0__Impl rule__ExclusiveOrExpression__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__ExclusiveOrExpression__Group_1__0__Impl_in_rule__ExclusiveOrExpression__Group_1__013449);

+            rule__ExclusiveOrExpression__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ExclusiveOrExpression__Group_1__1_in_rule__ExclusiveOrExpression__Group_1__013452);

+            rule__ExclusiveOrExpression__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ExclusiveOrExpression__Group_1__0"

+

+

+    // $ANTLR start "rule__ExclusiveOrExpression__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6335:1: rule__ExclusiveOrExpression__Group_1__0__Impl : ( '^' ) ;

+    public final void rule__ExclusiveOrExpression__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6339:1: ( ( '^' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6340:1: ( '^' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6340:1: ( '^' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6341:1: '^'

+            {

+             before(grammarAccess.getExclusiveOrExpressionAccess().getCircumflexAccentKeyword_1_0()); 

+            match(input,75,FOLLOW_75_in_rule__ExclusiveOrExpression__Group_1__0__Impl13480); 

+             after(grammarAccess.getExclusiveOrExpressionAccess().getCircumflexAccentKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ExclusiveOrExpression__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__ExclusiveOrExpression__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6354:1: rule__ExclusiveOrExpression__Group_1__1 : rule__ExclusiveOrExpression__Group_1__1__Impl ;

+    public final void rule__ExclusiveOrExpression__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6358:1: ( rule__ExclusiveOrExpression__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6359:2: rule__ExclusiveOrExpression__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ExclusiveOrExpression__Group_1__1__Impl_in_rule__ExclusiveOrExpression__Group_1__113511);

+            rule__ExclusiveOrExpression__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ExclusiveOrExpression__Group_1__1"

+

+

+    // $ANTLR start "rule__ExclusiveOrExpression__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6365:1: rule__ExclusiveOrExpression__Group_1__1__Impl : ( ( rule__ExclusiveOrExpression__ExpAssignment_1_1 ) ) ;

+    public final void rule__ExclusiveOrExpression__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6369:1: ( ( ( rule__ExclusiveOrExpression__ExpAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6370:1: ( ( rule__ExclusiveOrExpression__ExpAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6370:1: ( ( rule__ExclusiveOrExpression__ExpAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6371:1: ( rule__ExclusiveOrExpression__ExpAssignment_1_1 )

+            {

+             before(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6372:1: ( rule__ExclusiveOrExpression__ExpAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6372:2: rule__ExclusiveOrExpression__ExpAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__ExclusiveOrExpression__ExpAssignment_1_1_in_rule__ExclusiveOrExpression__Group_1__1__Impl13538);

+            rule__ExclusiveOrExpression__ExpAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getExclusiveOrExpressionAccess().getExpAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ExclusiveOrExpression__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__AndExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6386:1: rule__AndExpression__Group__0 : rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 ;

+    public final void rule__AndExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6390:1: ( rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6391:2: rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__AndExpression__Group__0__Impl_in_rule__AndExpression__Group__013572);

+            rule__AndExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AndExpression__Group__1_in_rule__AndExpression__Group__013575);

+            rule__AndExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AndExpression__Group__0"

+

+

+    // $ANTLR start "rule__AndExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6398:1: rule__AndExpression__Group__0__Impl : ( ( rule__AndExpression__ExpAssignment_0 ) ) ;

+    public final void rule__AndExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6402:1: ( ( ( rule__AndExpression__ExpAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6403:1: ( ( rule__AndExpression__ExpAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6403:1: ( ( rule__AndExpression__ExpAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6404:1: ( rule__AndExpression__ExpAssignment_0 )

+            {

+             before(grammarAccess.getAndExpressionAccess().getExpAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6405:1: ( rule__AndExpression__ExpAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6405:2: rule__AndExpression__ExpAssignment_0

+            {

+            pushFollow(FOLLOW_rule__AndExpression__ExpAssignment_0_in_rule__AndExpression__Group__0__Impl13602);

+            rule__AndExpression__ExpAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAndExpressionAccess().getExpAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AndExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__AndExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6415:1: rule__AndExpression__Group__1 : rule__AndExpression__Group__1__Impl ;

+    public final void rule__AndExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6419:1: ( rule__AndExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6420:2: rule__AndExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__AndExpression__Group__1__Impl_in_rule__AndExpression__Group__113632);

+            rule__AndExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AndExpression__Group__1"

+

+

+    // $ANTLR start "rule__AndExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6426:1: rule__AndExpression__Group__1__Impl : ( ( rule__AndExpression__Group_1__0 )* ) ;

+    public final void rule__AndExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6430:1: ( ( ( rule__AndExpression__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6431:1: ( ( rule__AndExpression__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6431:1: ( ( rule__AndExpression__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6432:1: ( rule__AndExpression__Group_1__0 )*

+            {

+             before(grammarAccess.getAndExpressionAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6433:1: ( rule__AndExpression__Group_1__0 )*

+            loop59:

+            do {

+                int alt59=2;

+                int LA59_0 = input.LA(1);

+

+                if ( (LA59_0==76) ) {

+                    alt59=1;

+                }

+

+

+                switch (alt59) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6433:2: rule__AndExpression__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__AndExpression__Group_1__0_in_rule__AndExpression__Group__1__Impl13659);

+            	    rule__AndExpression__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop59;

+                }

+            } while (true);

+

+             after(grammarAccess.getAndExpressionAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AndExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__AndExpression__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6447:1: rule__AndExpression__Group_1__0 : rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 ;

+    public final void rule__AndExpression__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6451:1: ( rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6452:2: rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__AndExpression__Group_1__0__Impl_in_rule__AndExpression__Group_1__013694);

+            rule__AndExpression__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AndExpression__Group_1__1_in_rule__AndExpression__Group_1__013697);

+            rule__AndExpression__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AndExpression__Group_1__0"

+

+

+    // $ANTLR start "rule__AndExpression__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6459:1: rule__AndExpression__Group_1__0__Impl : ( '&' ) ;

+    public final void rule__AndExpression__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6463:1: ( ( '&' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6464:1: ( '&' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6464:1: ( '&' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6465:1: '&'

+            {

+             before(grammarAccess.getAndExpressionAccess().getAmpersandKeyword_1_0()); 

+            match(input,76,FOLLOW_76_in_rule__AndExpression__Group_1__0__Impl13725); 

+             after(grammarAccess.getAndExpressionAccess().getAmpersandKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AndExpression__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__AndExpression__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6478:1: rule__AndExpression__Group_1__1 : rule__AndExpression__Group_1__1__Impl ;

+    public final void rule__AndExpression__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6482:1: ( rule__AndExpression__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6483:2: rule__AndExpression__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__AndExpression__Group_1__1__Impl_in_rule__AndExpression__Group_1__113756);

+            rule__AndExpression__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AndExpression__Group_1__1"

+

+

+    // $ANTLR start "rule__AndExpression__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6489:1: rule__AndExpression__Group_1__1__Impl : ( ( rule__AndExpression__ExpAssignment_1_1 ) ) ;

+    public final void rule__AndExpression__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6493:1: ( ( ( rule__AndExpression__ExpAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6494:1: ( ( rule__AndExpression__ExpAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6494:1: ( ( rule__AndExpression__ExpAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6495:1: ( rule__AndExpression__ExpAssignment_1_1 )

+            {

+             before(grammarAccess.getAndExpressionAccess().getExpAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6496:1: ( rule__AndExpression__ExpAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6496:2: rule__AndExpression__ExpAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__AndExpression__ExpAssignment_1_1_in_rule__AndExpression__Group_1__1__Impl13783);

+            rule__AndExpression__ExpAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAndExpressionAccess().getExpAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AndExpression__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__EqualityExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6510:1: rule__EqualityExpression__Group__0 : rule__EqualityExpression__Group__0__Impl rule__EqualityExpression__Group__1 ;

+    public final void rule__EqualityExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6514:1: ( rule__EqualityExpression__Group__0__Impl rule__EqualityExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6515:2: rule__EqualityExpression__Group__0__Impl rule__EqualityExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__EqualityExpression__Group__0__Impl_in_rule__EqualityExpression__Group__013817);

+            rule__EqualityExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__EqualityExpression__Group__1_in_rule__EqualityExpression__Group__013820);

+            rule__EqualityExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EqualityExpression__Group__0"

+

+

+    // $ANTLR start "rule__EqualityExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6522:1: rule__EqualityExpression__Group__0__Impl : ( ( rule__EqualityExpression__ExpAssignment_0 ) ) ;

+    public final void rule__EqualityExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6526:1: ( ( ( rule__EqualityExpression__ExpAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6527:1: ( ( rule__EqualityExpression__ExpAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6527:1: ( ( rule__EqualityExpression__ExpAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6528:1: ( rule__EqualityExpression__ExpAssignment_0 )

+            {

+             before(grammarAccess.getEqualityExpressionAccess().getExpAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6529:1: ( rule__EqualityExpression__ExpAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6529:2: rule__EqualityExpression__ExpAssignment_0

+            {

+            pushFollow(FOLLOW_rule__EqualityExpression__ExpAssignment_0_in_rule__EqualityExpression__Group__0__Impl13847);

+            rule__EqualityExpression__ExpAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getEqualityExpressionAccess().getExpAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EqualityExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__EqualityExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6539:1: rule__EqualityExpression__Group__1 : rule__EqualityExpression__Group__1__Impl ;

+    public final void rule__EqualityExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6543:1: ( rule__EqualityExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6544:2: rule__EqualityExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__EqualityExpression__Group__1__Impl_in_rule__EqualityExpression__Group__113877);

+            rule__EqualityExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EqualityExpression__Group__1"

+

+

+    // $ANTLR start "rule__EqualityExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6550:1: rule__EqualityExpression__Group__1__Impl : ( ( rule__EqualityExpression__Group_1__0 )* ) ;

+    public final void rule__EqualityExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6554:1: ( ( ( rule__EqualityExpression__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6555:1: ( ( rule__EqualityExpression__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6555:1: ( ( rule__EqualityExpression__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6556:1: ( rule__EqualityExpression__Group_1__0 )*

+            {

+             before(grammarAccess.getEqualityExpressionAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6557:1: ( rule__EqualityExpression__Group_1__0 )*

+            loop60:

+            do {

+                int alt60=2;

+                int LA60_0 = input.LA(1);

+

+                if ( ((LA60_0>=14 && LA60_0<=15)) ) {

+                    alt60=1;

+                }

+

+

+                switch (alt60) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6557:2: rule__EqualityExpression__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__EqualityExpression__Group_1__0_in_rule__EqualityExpression__Group__1__Impl13904);

+            	    rule__EqualityExpression__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop60;

+                }

+            } while (true);

+

+             after(grammarAccess.getEqualityExpressionAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EqualityExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__EqualityExpression__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6571:1: rule__EqualityExpression__Group_1__0 : rule__EqualityExpression__Group_1__0__Impl rule__EqualityExpression__Group_1__1 ;

+    public final void rule__EqualityExpression__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6575:1: ( rule__EqualityExpression__Group_1__0__Impl rule__EqualityExpression__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6576:2: rule__EqualityExpression__Group_1__0__Impl rule__EqualityExpression__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__EqualityExpression__Group_1__0__Impl_in_rule__EqualityExpression__Group_1__013939);

+            rule__EqualityExpression__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__EqualityExpression__Group_1__1_in_rule__EqualityExpression__Group_1__013942);

+            rule__EqualityExpression__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EqualityExpression__Group_1__0"

+

+

+    // $ANTLR start "rule__EqualityExpression__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6583:1: rule__EqualityExpression__Group_1__0__Impl : ( ( rule__EqualityExpression__OpAssignment_1_0 ) ) ;

+    public final void rule__EqualityExpression__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6587:1: ( ( ( rule__EqualityExpression__OpAssignment_1_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6588:1: ( ( rule__EqualityExpression__OpAssignment_1_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6588:1: ( ( rule__EqualityExpression__OpAssignment_1_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6589:1: ( rule__EqualityExpression__OpAssignment_1_0 )

+            {

+             before(grammarAccess.getEqualityExpressionAccess().getOpAssignment_1_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6590:1: ( rule__EqualityExpression__OpAssignment_1_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6590:2: rule__EqualityExpression__OpAssignment_1_0

+            {

+            pushFollow(FOLLOW_rule__EqualityExpression__OpAssignment_1_0_in_rule__EqualityExpression__Group_1__0__Impl13969);

+            rule__EqualityExpression__OpAssignment_1_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getEqualityExpressionAccess().getOpAssignment_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EqualityExpression__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__EqualityExpression__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6600:1: rule__EqualityExpression__Group_1__1 : rule__EqualityExpression__Group_1__1__Impl ;

+    public final void rule__EqualityExpression__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6604:1: ( rule__EqualityExpression__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6605:2: rule__EqualityExpression__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__EqualityExpression__Group_1__1__Impl_in_rule__EqualityExpression__Group_1__113999);

+            rule__EqualityExpression__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EqualityExpression__Group_1__1"

+

+

+    // $ANTLR start "rule__EqualityExpression__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6611:1: rule__EqualityExpression__Group_1__1__Impl : ( ( rule__EqualityExpression__ExpAssignment_1_1 ) ) ;

+    public final void rule__EqualityExpression__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6615:1: ( ( ( rule__EqualityExpression__ExpAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6616:1: ( ( rule__EqualityExpression__ExpAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6616:1: ( ( rule__EqualityExpression__ExpAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6617:1: ( rule__EqualityExpression__ExpAssignment_1_1 )

+            {

+             before(grammarAccess.getEqualityExpressionAccess().getExpAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6618:1: ( rule__EqualityExpression__ExpAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6618:2: rule__EqualityExpression__ExpAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__EqualityExpression__ExpAssignment_1_1_in_rule__EqualityExpression__Group_1__1__Impl14026);

+            rule__EqualityExpression__ExpAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getEqualityExpressionAccess().getExpAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EqualityExpression__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__ClassificationExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6632:1: rule__ClassificationExpression__Group__0 : rule__ClassificationExpression__Group__0__Impl rule__ClassificationExpression__Group__1 ;

+    public final void rule__ClassificationExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6636:1: ( rule__ClassificationExpression__Group__0__Impl rule__ClassificationExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6637:2: rule__ClassificationExpression__Group__0__Impl rule__ClassificationExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__ClassificationExpression__Group__0__Impl_in_rule__ClassificationExpression__Group__014060);

+            rule__ClassificationExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ClassificationExpression__Group__1_in_rule__ClassificationExpression__Group__014063);

+            rule__ClassificationExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationExpression__Group__0"

+

+

+    // $ANTLR start "rule__ClassificationExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6644:1: rule__ClassificationExpression__Group__0__Impl : ( ( rule__ClassificationExpression__ExpAssignment_0 ) ) ;

+    public final void rule__ClassificationExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6648:1: ( ( ( rule__ClassificationExpression__ExpAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6649:1: ( ( rule__ClassificationExpression__ExpAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6649:1: ( ( rule__ClassificationExpression__ExpAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6650:1: ( rule__ClassificationExpression__ExpAssignment_0 )

+            {

+             before(grammarAccess.getClassificationExpressionAccess().getExpAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6651:1: ( rule__ClassificationExpression__ExpAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6651:2: rule__ClassificationExpression__ExpAssignment_0

+            {

+            pushFollow(FOLLOW_rule__ClassificationExpression__ExpAssignment_0_in_rule__ClassificationExpression__Group__0__Impl14090);

+            rule__ClassificationExpression__ExpAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassificationExpressionAccess().getExpAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ClassificationExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6661:1: rule__ClassificationExpression__Group__1 : rule__ClassificationExpression__Group__1__Impl ;

+    public final void rule__ClassificationExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6665:1: ( rule__ClassificationExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6666:2: rule__ClassificationExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ClassificationExpression__Group__1__Impl_in_rule__ClassificationExpression__Group__114120);

+            rule__ClassificationExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationExpression__Group__1"

+

+

+    // $ANTLR start "rule__ClassificationExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6672:1: rule__ClassificationExpression__Group__1__Impl : ( ( rule__ClassificationExpression__Group_1__0 )? ) ;

+    public final void rule__ClassificationExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6676:1: ( ( ( rule__ClassificationExpression__Group_1__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6677:1: ( ( rule__ClassificationExpression__Group_1__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6677:1: ( ( rule__ClassificationExpression__Group_1__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6678:1: ( rule__ClassificationExpression__Group_1__0 )?

+            {

+             before(grammarAccess.getClassificationExpressionAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6679:1: ( rule__ClassificationExpression__Group_1__0 )?

+            int alt61=2;

+            int LA61_0 = input.LA(1);

+

+            if ( ((LA61_0>=16 && LA61_0<=17)) ) {

+                alt61=1;

+            }

+            switch (alt61) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6679:2: rule__ClassificationExpression__Group_1__0

+                    {

+                    pushFollow(FOLLOW_rule__ClassificationExpression__Group_1__0_in_rule__ClassificationExpression__Group__1__Impl14147);

+                    rule__ClassificationExpression__Group_1__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getClassificationExpressionAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ClassificationExpression__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6693:1: rule__ClassificationExpression__Group_1__0 : rule__ClassificationExpression__Group_1__0__Impl rule__ClassificationExpression__Group_1__1 ;

+    public final void rule__ClassificationExpression__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6697:1: ( rule__ClassificationExpression__Group_1__0__Impl rule__ClassificationExpression__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6698:2: rule__ClassificationExpression__Group_1__0__Impl rule__ClassificationExpression__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__ClassificationExpression__Group_1__0__Impl_in_rule__ClassificationExpression__Group_1__014182);

+            rule__ClassificationExpression__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ClassificationExpression__Group_1__1_in_rule__ClassificationExpression__Group_1__014185);

+            rule__ClassificationExpression__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationExpression__Group_1__0"

+

+

+    // $ANTLR start "rule__ClassificationExpression__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6705:1: rule__ClassificationExpression__Group_1__0__Impl : ( ( rule__ClassificationExpression__OpAssignment_1_0 ) ) ;

+    public final void rule__ClassificationExpression__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6709:1: ( ( ( rule__ClassificationExpression__OpAssignment_1_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6710:1: ( ( rule__ClassificationExpression__OpAssignment_1_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6710:1: ( ( rule__ClassificationExpression__OpAssignment_1_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6711:1: ( rule__ClassificationExpression__OpAssignment_1_0 )

+            {

+             before(grammarAccess.getClassificationExpressionAccess().getOpAssignment_1_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6712:1: ( rule__ClassificationExpression__OpAssignment_1_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6712:2: rule__ClassificationExpression__OpAssignment_1_0

+            {

+            pushFollow(FOLLOW_rule__ClassificationExpression__OpAssignment_1_0_in_rule__ClassificationExpression__Group_1__0__Impl14212);

+            rule__ClassificationExpression__OpAssignment_1_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassificationExpressionAccess().getOpAssignment_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationExpression__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__ClassificationExpression__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6722:1: rule__ClassificationExpression__Group_1__1 : rule__ClassificationExpression__Group_1__1__Impl ;

+    public final void rule__ClassificationExpression__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6726:1: ( rule__ClassificationExpression__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6727:2: rule__ClassificationExpression__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ClassificationExpression__Group_1__1__Impl_in_rule__ClassificationExpression__Group_1__114242);

+            rule__ClassificationExpression__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationExpression__Group_1__1"

+

+

+    // $ANTLR start "rule__ClassificationExpression__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6733:1: rule__ClassificationExpression__Group_1__1__Impl : ( ( rule__ClassificationExpression__TypeNameAssignment_1_1 ) ) ;

+    public final void rule__ClassificationExpression__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6737:1: ( ( ( rule__ClassificationExpression__TypeNameAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6738:1: ( ( rule__ClassificationExpression__TypeNameAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6738:1: ( ( rule__ClassificationExpression__TypeNameAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6739:1: ( rule__ClassificationExpression__TypeNameAssignment_1_1 )

+            {

+             before(grammarAccess.getClassificationExpressionAccess().getTypeNameAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6740:1: ( rule__ClassificationExpression__TypeNameAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6740:2: rule__ClassificationExpression__TypeNameAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__ClassificationExpression__TypeNameAssignment_1_1_in_rule__ClassificationExpression__Group_1__1__Impl14269);

+            rule__ClassificationExpression__TypeNameAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassificationExpressionAccess().getTypeNameAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationExpression__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__RelationalExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6754:1: rule__RelationalExpression__Group__0 : rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ;

+    public final void rule__RelationalExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6758:1: ( rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6759:2: rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__RelationalExpression__Group__0__Impl_in_rule__RelationalExpression__Group__014303);

+            rule__RelationalExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__RelationalExpression__Group__1_in_rule__RelationalExpression__Group__014306);

+            rule__RelationalExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__RelationalExpression__Group__0"

+

+

+    // $ANTLR start "rule__RelationalExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6766:1: rule__RelationalExpression__Group__0__Impl : ( ( rule__RelationalExpression__LeftAssignment_0 ) ) ;

+    public final void rule__RelationalExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6770:1: ( ( ( rule__RelationalExpression__LeftAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6771:1: ( ( rule__RelationalExpression__LeftAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6771:1: ( ( rule__RelationalExpression__LeftAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6772:1: ( rule__RelationalExpression__LeftAssignment_0 )

+            {

+             before(grammarAccess.getRelationalExpressionAccess().getLeftAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6773:1: ( rule__RelationalExpression__LeftAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6773:2: rule__RelationalExpression__LeftAssignment_0

+            {

+            pushFollow(FOLLOW_rule__RelationalExpression__LeftAssignment_0_in_rule__RelationalExpression__Group__0__Impl14333);

+            rule__RelationalExpression__LeftAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getRelationalExpressionAccess().getLeftAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__RelationalExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__RelationalExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6783:1: rule__RelationalExpression__Group__1 : rule__RelationalExpression__Group__1__Impl ;

+    public final void rule__RelationalExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6787:1: ( rule__RelationalExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6788:2: rule__RelationalExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__RelationalExpression__Group__1__Impl_in_rule__RelationalExpression__Group__114363);

+            rule__RelationalExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__RelationalExpression__Group__1"

+

+

+    // $ANTLR start "rule__RelationalExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6794:1: rule__RelationalExpression__Group__1__Impl : ( ( rule__RelationalExpression__Group_1__0 )? ) ;

+    public final void rule__RelationalExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6798:1: ( ( ( rule__RelationalExpression__Group_1__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6799:1: ( ( rule__RelationalExpression__Group_1__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6799:1: ( ( rule__RelationalExpression__Group_1__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6800:1: ( rule__RelationalExpression__Group_1__0 )?

+            {

+             before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6801:1: ( rule__RelationalExpression__Group_1__0 )?

+            int alt62=2;

+            int LA62_0 = input.LA(1);

+

+            if ( ((LA62_0>=18 && LA62_0<=21)) ) {

+                alt62=1;

+            }

+            switch (alt62) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6801:2: rule__RelationalExpression__Group_1__0

+                    {

+                    pushFollow(FOLLOW_rule__RelationalExpression__Group_1__0_in_rule__RelationalExpression__Group__1__Impl14390);

+                    rule__RelationalExpression__Group_1__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__RelationalExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__RelationalExpression__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6815:1: rule__RelationalExpression__Group_1__0 : rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 ;

+    public final void rule__RelationalExpression__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6819:1: ( rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6820:2: rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__RelationalExpression__Group_1__0__Impl_in_rule__RelationalExpression__Group_1__014425);

+            rule__RelationalExpression__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__RelationalExpression__Group_1__1_in_rule__RelationalExpression__Group_1__014428);

+            rule__RelationalExpression__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__RelationalExpression__Group_1__0"

+

+

+    // $ANTLR start "rule__RelationalExpression__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6827:1: rule__RelationalExpression__Group_1__0__Impl : ( ( rule__RelationalExpression__OpAssignment_1_0 ) ) ;

+    public final void rule__RelationalExpression__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6831:1: ( ( ( rule__RelationalExpression__OpAssignment_1_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6832:1: ( ( rule__RelationalExpression__OpAssignment_1_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6832:1: ( ( rule__RelationalExpression__OpAssignment_1_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6833:1: ( rule__RelationalExpression__OpAssignment_1_0 )

+            {

+             before(grammarAccess.getRelationalExpressionAccess().getOpAssignment_1_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6834:1: ( rule__RelationalExpression__OpAssignment_1_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6834:2: rule__RelationalExpression__OpAssignment_1_0

+            {

+            pushFollow(FOLLOW_rule__RelationalExpression__OpAssignment_1_0_in_rule__RelationalExpression__Group_1__0__Impl14455);

+            rule__RelationalExpression__OpAssignment_1_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getRelationalExpressionAccess().getOpAssignment_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__RelationalExpression__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__RelationalExpression__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6844:1: rule__RelationalExpression__Group_1__1 : rule__RelationalExpression__Group_1__1__Impl ;

+    public final void rule__RelationalExpression__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6848:1: ( rule__RelationalExpression__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6849:2: rule__RelationalExpression__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__RelationalExpression__Group_1__1__Impl_in_rule__RelationalExpression__Group_1__114485);

+            rule__RelationalExpression__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__RelationalExpression__Group_1__1"

+

+

+    // $ANTLR start "rule__RelationalExpression__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6855:1: rule__RelationalExpression__Group_1__1__Impl : ( ( rule__RelationalExpression__RightAssignment_1_1 ) ) ;

+    public final void rule__RelationalExpression__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6859:1: ( ( ( rule__RelationalExpression__RightAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6860:1: ( ( rule__RelationalExpression__RightAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6860:1: ( ( rule__RelationalExpression__RightAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6861:1: ( rule__RelationalExpression__RightAssignment_1_1 )

+            {

+             before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6862:1: ( rule__RelationalExpression__RightAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6862:2: rule__RelationalExpression__RightAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__RelationalExpression__RightAssignment_1_1_in_rule__RelationalExpression__Group_1__1__Impl14512);

+            rule__RelationalExpression__RightAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__RelationalExpression__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__ShiftExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6876:1: rule__ShiftExpression__Group__0 : rule__ShiftExpression__Group__0__Impl rule__ShiftExpression__Group__1 ;

+    public final void rule__ShiftExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6880:1: ( rule__ShiftExpression__Group__0__Impl rule__ShiftExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6881:2: rule__ShiftExpression__Group__0__Impl rule__ShiftExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__ShiftExpression__Group__0__Impl_in_rule__ShiftExpression__Group__014546);

+            rule__ShiftExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ShiftExpression__Group__1_in_rule__ShiftExpression__Group__014549);

+            rule__ShiftExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ShiftExpression__Group__0"

+

+

+    // $ANTLR start "rule__ShiftExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6888:1: rule__ShiftExpression__Group__0__Impl : ( ( rule__ShiftExpression__ExpAssignment_0 ) ) ;

+    public final void rule__ShiftExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6892:1: ( ( ( rule__ShiftExpression__ExpAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6893:1: ( ( rule__ShiftExpression__ExpAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6893:1: ( ( rule__ShiftExpression__ExpAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6894:1: ( rule__ShiftExpression__ExpAssignment_0 )

+            {

+             before(grammarAccess.getShiftExpressionAccess().getExpAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6895:1: ( rule__ShiftExpression__ExpAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6895:2: rule__ShiftExpression__ExpAssignment_0

+            {

+            pushFollow(FOLLOW_rule__ShiftExpression__ExpAssignment_0_in_rule__ShiftExpression__Group__0__Impl14576);

+            rule__ShiftExpression__ExpAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getShiftExpressionAccess().getExpAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ShiftExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ShiftExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6905:1: rule__ShiftExpression__Group__1 : rule__ShiftExpression__Group__1__Impl ;

+    public final void rule__ShiftExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6909:1: ( rule__ShiftExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6910:2: rule__ShiftExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ShiftExpression__Group__1__Impl_in_rule__ShiftExpression__Group__114606);

+            rule__ShiftExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ShiftExpression__Group__1"

+

+

+    // $ANTLR start "rule__ShiftExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6916:1: rule__ShiftExpression__Group__1__Impl : ( ( rule__ShiftExpression__Group_1__0 )? ) ;

+    public final void rule__ShiftExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6920:1: ( ( ( rule__ShiftExpression__Group_1__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6921:1: ( ( rule__ShiftExpression__Group_1__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6921:1: ( ( rule__ShiftExpression__Group_1__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6922:1: ( rule__ShiftExpression__Group_1__0 )?

+            {

+             before(grammarAccess.getShiftExpressionAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6923:1: ( rule__ShiftExpression__Group_1__0 )?

+            int alt63=2;

+            int LA63_0 = input.LA(1);

+

+            if ( ((LA63_0>=22 && LA63_0<=24)) ) {

+                alt63=1;

+            }

+            switch (alt63) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6923:2: rule__ShiftExpression__Group_1__0

+                    {

+                    pushFollow(FOLLOW_rule__ShiftExpression__Group_1__0_in_rule__ShiftExpression__Group__1__Impl14633);

+                    rule__ShiftExpression__Group_1__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getShiftExpressionAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ShiftExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ShiftExpression__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6937:1: rule__ShiftExpression__Group_1__0 : rule__ShiftExpression__Group_1__0__Impl rule__ShiftExpression__Group_1__1 ;

+    public final void rule__ShiftExpression__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6941:1: ( rule__ShiftExpression__Group_1__0__Impl rule__ShiftExpression__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6942:2: rule__ShiftExpression__Group_1__0__Impl rule__ShiftExpression__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__ShiftExpression__Group_1__0__Impl_in_rule__ShiftExpression__Group_1__014668);

+            rule__ShiftExpression__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ShiftExpression__Group_1__1_in_rule__ShiftExpression__Group_1__014671);

+            rule__ShiftExpression__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ShiftExpression__Group_1__0"

+

+

+    // $ANTLR start "rule__ShiftExpression__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6949:1: rule__ShiftExpression__Group_1__0__Impl : ( ( rule__ShiftExpression__OpAssignment_1_0 ) ) ;

+    public final void rule__ShiftExpression__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6953:1: ( ( ( rule__ShiftExpression__OpAssignment_1_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6954:1: ( ( rule__ShiftExpression__OpAssignment_1_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6954:1: ( ( rule__ShiftExpression__OpAssignment_1_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6955:1: ( rule__ShiftExpression__OpAssignment_1_0 )

+            {

+             before(grammarAccess.getShiftExpressionAccess().getOpAssignment_1_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6956:1: ( rule__ShiftExpression__OpAssignment_1_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6956:2: rule__ShiftExpression__OpAssignment_1_0

+            {

+            pushFollow(FOLLOW_rule__ShiftExpression__OpAssignment_1_0_in_rule__ShiftExpression__Group_1__0__Impl14698);

+            rule__ShiftExpression__OpAssignment_1_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getShiftExpressionAccess().getOpAssignment_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ShiftExpression__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__ShiftExpression__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6966:1: rule__ShiftExpression__Group_1__1 : rule__ShiftExpression__Group_1__1__Impl ;

+    public final void rule__ShiftExpression__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6970:1: ( rule__ShiftExpression__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6971:2: rule__ShiftExpression__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ShiftExpression__Group_1__1__Impl_in_rule__ShiftExpression__Group_1__114728);

+            rule__ShiftExpression__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ShiftExpression__Group_1__1"

+

+

+    // $ANTLR start "rule__ShiftExpression__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6977:1: rule__ShiftExpression__Group_1__1__Impl : ( ( rule__ShiftExpression__ExpAssignment_1_1 ) ) ;

+    public final void rule__ShiftExpression__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6981:1: ( ( ( rule__ShiftExpression__ExpAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6982:1: ( ( rule__ShiftExpression__ExpAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6982:1: ( ( rule__ShiftExpression__ExpAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6983:1: ( rule__ShiftExpression__ExpAssignment_1_1 )

+            {

+             before(grammarAccess.getShiftExpressionAccess().getExpAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6984:1: ( rule__ShiftExpression__ExpAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6984:2: rule__ShiftExpression__ExpAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__ShiftExpression__ExpAssignment_1_1_in_rule__ShiftExpression__Group_1__1__Impl14755);

+            rule__ShiftExpression__ExpAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getShiftExpressionAccess().getExpAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ShiftExpression__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__AdditiveExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:6998:1: rule__AdditiveExpression__Group__0 : rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ;

+    public final void rule__AdditiveExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7002:1: ( rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7003:2: rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__AdditiveExpression__Group__0__Impl_in_rule__AdditiveExpression__Group__014789);

+            rule__AdditiveExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AdditiveExpression__Group__1_in_rule__AdditiveExpression__Group__014792);

+            rule__AdditiveExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AdditiveExpression__Group__0"

+

+

+    // $ANTLR start "rule__AdditiveExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7010:1: rule__AdditiveExpression__Group__0__Impl : ( ( rule__AdditiveExpression__ExpAssignment_0 ) ) ;

+    public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7014:1: ( ( ( rule__AdditiveExpression__ExpAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7015:1: ( ( rule__AdditiveExpression__ExpAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7015:1: ( ( rule__AdditiveExpression__ExpAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7016:1: ( rule__AdditiveExpression__ExpAssignment_0 )

+            {

+             before(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7017:1: ( rule__AdditiveExpression__ExpAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7017:2: rule__AdditiveExpression__ExpAssignment_0

+            {

+            pushFollow(FOLLOW_rule__AdditiveExpression__ExpAssignment_0_in_rule__AdditiveExpression__Group__0__Impl14819);

+            rule__AdditiveExpression__ExpAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AdditiveExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__AdditiveExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7027:1: rule__AdditiveExpression__Group__1 : rule__AdditiveExpression__Group__1__Impl ;

+    public final void rule__AdditiveExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7031:1: ( rule__AdditiveExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7032:2: rule__AdditiveExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__AdditiveExpression__Group__1__Impl_in_rule__AdditiveExpression__Group__114849);

+            rule__AdditiveExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AdditiveExpression__Group__1"

+

+

+    // $ANTLR start "rule__AdditiveExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7038:1: rule__AdditiveExpression__Group__1__Impl : ( ( rule__AdditiveExpression__Group_1__0 )* ) ;

+    public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7042:1: ( ( ( rule__AdditiveExpression__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7043:1: ( ( rule__AdditiveExpression__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7043:1: ( ( rule__AdditiveExpression__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7044:1: ( rule__AdditiveExpression__Group_1__0 )*

+            {

+             before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7045:1: ( rule__AdditiveExpression__Group_1__0 )*

+            loop64:

+            do {

+                int alt64=2;

+                int LA64_0 = input.LA(1);

+

+                if ( ((LA64_0>=25 && LA64_0<=26)) ) {

+                    alt64=1;

+                }

+

+

+                switch (alt64) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7045:2: rule__AdditiveExpression__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__AdditiveExpression__Group_1__0_in_rule__AdditiveExpression__Group__1__Impl14876);

+            	    rule__AdditiveExpression__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop64;

+                }

+            } while (true);

+

+             after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AdditiveExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__AdditiveExpression__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7059:1: rule__AdditiveExpression__Group_1__0 : rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ;

+    public final void rule__AdditiveExpression__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7063:1: ( rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7064:2: rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__AdditiveExpression__Group_1__0__Impl_in_rule__AdditiveExpression__Group_1__014911);

+            rule__AdditiveExpression__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AdditiveExpression__Group_1__1_in_rule__AdditiveExpression__Group_1__014914);

+            rule__AdditiveExpression__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AdditiveExpression__Group_1__0"

+

+

+    // $ANTLR start "rule__AdditiveExpression__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7071:1: rule__AdditiveExpression__Group_1__0__Impl : ( ( rule__AdditiveExpression__OpAssignment_1_0 ) ) ;

+    public final void rule__AdditiveExpression__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7075:1: ( ( ( rule__AdditiveExpression__OpAssignment_1_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7076:1: ( ( rule__AdditiveExpression__OpAssignment_1_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7076:1: ( ( rule__AdditiveExpression__OpAssignment_1_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7077:1: ( rule__AdditiveExpression__OpAssignment_1_0 )

+            {

+             before(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7078:1: ( rule__AdditiveExpression__OpAssignment_1_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7078:2: rule__AdditiveExpression__OpAssignment_1_0

+            {

+            pushFollow(FOLLOW_rule__AdditiveExpression__OpAssignment_1_0_in_rule__AdditiveExpression__Group_1__0__Impl14941);

+            rule__AdditiveExpression__OpAssignment_1_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AdditiveExpression__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__AdditiveExpression__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7088:1: rule__AdditiveExpression__Group_1__1 : rule__AdditiveExpression__Group_1__1__Impl ;

+    public final void rule__AdditiveExpression__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7092:1: ( rule__AdditiveExpression__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7093:2: rule__AdditiveExpression__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__AdditiveExpression__Group_1__1__Impl_in_rule__AdditiveExpression__Group_1__114971);

+            rule__AdditiveExpression__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AdditiveExpression__Group_1__1"

+

+

+    // $ANTLR start "rule__AdditiveExpression__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7099:1: rule__AdditiveExpression__Group_1__1__Impl : ( ( rule__AdditiveExpression__ExpAssignment_1_1 ) ) ;

+    public final void rule__AdditiveExpression__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7103:1: ( ( ( rule__AdditiveExpression__ExpAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7104:1: ( ( rule__AdditiveExpression__ExpAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7104:1: ( ( rule__AdditiveExpression__ExpAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7105:1: ( rule__AdditiveExpression__ExpAssignment_1_1 )

+            {

+             before(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7106:1: ( rule__AdditiveExpression__ExpAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7106:2: rule__AdditiveExpression__ExpAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__AdditiveExpression__ExpAssignment_1_1_in_rule__AdditiveExpression__Group_1__1__Impl14998);

+            rule__AdditiveExpression__ExpAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAdditiveExpressionAccess().getExpAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AdditiveExpression__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__MultiplicativeExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7120:1: rule__MultiplicativeExpression__Group__0 : rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ;

+    public final void rule__MultiplicativeExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7124:1: ( rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7125:2: rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__MultiplicativeExpression__Group__0__Impl_in_rule__MultiplicativeExpression__Group__015032);

+            rule__MultiplicativeExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__MultiplicativeExpression__Group__1_in_rule__MultiplicativeExpression__Group__015035);

+            rule__MultiplicativeExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__MultiplicativeExpression__Group__0"

+

+

+    // $ANTLR start "rule__MultiplicativeExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7132:1: rule__MultiplicativeExpression__Group__0__Impl : ( ( rule__MultiplicativeExpression__ExpAssignment_0 ) ) ;

+    public final void rule__MultiplicativeExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7136:1: ( ( ( rule__MultiplicativeExpression__ExpAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7137:1: ( ( rule__MultiplicativeExpression__ExpAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7137:1: ( ( rule__MultiplicativeExpression__ExpAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7138:1: ( rule__MultiplicativeExpression__ExpAssignment_0 )

+            {

+             before(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7139:1: ( rule__MultiplicativeExpression__ExpAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7139:2: rule__MultiplicativeExpression__ExpAssignment_0

+            {

+            pushFollow(FOLLOW_rule__MultiplicativeExpression__ExpAssignment_0_in_rule__MultiplicativeExpression__Group__0__Impl15062);

+            rule__MultiplicativeExpression__ExpAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__MultiplicativeExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__MultiplicativeExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7149:1: rule__MultiplicativeExpression__Group__1 : rule__MultiplicativeExpression__Group__1__Impl ;

+    public final void rule__MultiplicativeExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7153:1: ( rule__MultiplicativeExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7154:2: rule__MultiplicativeExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__MultiplicativeExpression__Group__1__Impl_in_rule__MultiplicativeExpression__Group__115092);

+            rule__MultiplicativeExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__MultiplicativeExpression__Group__1"

+

+

+    // $ANTLR start "rule__MultiplicativeExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7160:1: rule__MultiplicativeExpression__Group__1__Impl : ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ;

+    public final void rule__MultiplicativeExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7164:1: ( ( ( rule__MultiplicativeExpression__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7165:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7165:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7166:1: ( rule__MultiplicativeExpression__Group_1__0 )*

+            {

+             before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7167:1: ( rule__MultiplicativeExpression__Group_1__0 )*

+            loop65:

+            do {

+                int alt65=2;

+                int LA65_0 = input.LA(1);

+

+                if ( ((LA65_0>=27 && LA65_0<=29)) ) {

+                    alt65=1;

+                }

+

+

+                switch (alt65) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7167:2: rule__MultiplicativeExpression__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__MultiplicativeExpression__Group_1__0_in_rule__MultiplicativeExpression__Group__1__Impl15119);

+            	    rule__MultiplicativeExpression__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop65;

+                }

+            } while (true);

+

+             after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__MultiplicativeExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__MultiplicativeExpression__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7181:1: rule__MultiplicativeExpression__Group_1__0 : rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ;

+    public final void rule__MultiplicativeExpression__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7185:1: ( rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7186:2: rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__MultiplicativeExpression__Group_1__0__Impl_in_rule__MultiplicativeExpression__Group_1__015154);

+            rule__MultiplicativeExpression__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__MultiplicativeExpression__Group_1__1_in_rule__MultiplicativeExpression__Group_1__015157);

+            rule__MultiplicativeExpression__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__MultiplicativeExpression__Group_1__0"

+

+

+    // $ANTLR start "rule__MultiplicativeExpression__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7193:1: rule__MultiplicativeExpression__Group_1__0__Impl : ( ( rule__MultiplicativeExpression__OpAssignment_1_0 ) ) ;

+    public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7197:1: ( ( ( rule__MultiplicativeExpression__OpAssignment_1_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7198:1: ( ( rule__MultiplicativeExpression__OpAssignment_1_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7198:1: ( ( rule__MultiplicativeExpression__OpAssignment_1_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7199:1: ( rule__MultiplicativeExpression__OpAssignment_1_0 )

+            {

+             before(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7200:1: ( rule__MultiplicativeExpression__OpAssignment_1_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7200:2: rule__MultiplicativeExpression__OpAssignment_1_0

+            {

+            pushFollow(FOLLOW_rule__MultiplicativeExpression__OpAssignment_1_0_in_rule__MultiplicativeExpression__Group_1__0__Impl15184);

+            rule__MultiplicativeExpression__OpAssignment_1_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__MultiplicativeExpression__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__MultiplicativeExpression__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7210:1: rule__MultiplicativeExpression__Group_1__1 : rule__MultiplicativeExpression__Group_1__1__Impl ;

+    public final void rule__MultiplicativeExpression__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7214:1: ( rule__MultiplicativeExpression__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7215:2: rule__MultiplicativeExpression__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__MultiplicativeExpression__Group_1__1__Impl_in_rule__MultiplicativeExpression__Group_1__115214);

+            rule__MultiplicativeExpression__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__MultiplicativeExpression__Group_1__1"

+

+

+    // $ANTLR start "rule__MultiplicativeExpression__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7221:1: rule__MultiplicativeExpression__Group_1__1__Impl : ( ( rule__MultiplicativeExpression__ExpAssignment_1_1 ) ) ;

+    public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7225:1: ( ( ( rule__MultiplicativeExpression__ExpAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7226:1: ( ( rule__MultiplicativeExpression__ExpAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7226:1: ( ( rule__MultiplicativeExpression__ExpAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7227:1: ( rule__MultiplicativeExpression__ExpAssignment_1_1 )

+            {

+             before(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7228:1: ( rule__MultiplicativeExpression__ExpAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7228:2: rule__MultiplicativeExpression__ExpAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__MultiplicativeExpression__ExpAssignment_1_1_in_rule__MultiplicativeExpression__Group_1__1__Impl15241);

+            rule__MultiplicativeExpression__ExpAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getMultiplicativeExpressionAccess().getExpAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__MultiplicativeExpression__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__UnaryExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7242:1: rule__UnaryExpression__Group__0 : rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 ;

+    public final void rule__UnaryExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7246:1: ( rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7247:2: rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__UnaryExpression__Group__0__Impl_in_rule__UnaryExpression__Group__015275);

+            rule__UnaryExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__UnaryExpression__Group__1_in_rule__UnaryExpression__Group__015278);

+            rule__UnaryExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UnaryExpression__Group__0"

+

+

+    // $ANTLR start "rule__UnaryExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7254:1: rule__UnaryExpression__Group__0__Impl : ( ( rule__UnaryExpression__OpAssignment_0 )? ) ;

+    public final void rule__UnaryExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7258:1: ( ( ( rule__UnaryExpression__OpAssignment_0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7259:1: ( ( rule__UnaryExpression__OpAssignment_0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7259:1: ( ( rule__UnaryExpression__OpAssignment_0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7260:1: ( rule__UnaryExpression__OpAssignment_0 )?

+            {

+             before(grammarAccess.getUnaryExpressionAccess().getOpAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7261:1: ( rule__UnaryExpression__OpAssignment_0 )?

+            int alt66=2;

+            int LA66_0 = input.LA(1);

+

+            if ( ((LA66_0>=25 && LA66_0<=26)||(LA66_0>=30 && LA66_0<=32)) ) {

+                alt66=1;

+            }

+            switch (alt66) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7261:2: rule__UnaryExpression__OpAssignment_0

+                    {

+                    pushFollow(FOLLOW_rule__UnaryExpression__OpAssignment_0_in_rule__UnaryExpression__Group__0__Impl15305);

+                    rule__UnaryExpression__OpAssignment_0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getUnaryExpressionAccess().getOpAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UnaryExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__UnaryExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7271:1: rule__UnaryExpression__Group__1 : rule__UnaryExpression__Group__1__Impl ;

+    public final void rule__UnaryExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7275:1: ( rule__UnaryExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7276:2: rule__UnaryExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__UnaryExpression__Group__1__Impl_in_rule__UnaryExpression__Group__115336);

+            rule__UnaryExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UnaryExpression__Group__1"

+

+

+    // $ANTLR start "rule__UnaryExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7282:1: rule__UnaryExpression__Group__1__Impl : ( ( rule__UnaryExpression__ExpAssignment_1 ) ) ;

+    public final void rule__UnaryExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7286:1: ( ( ( rule__UnaryExpression__ExpAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7287:1: ( ( rule__UnaryExpression__ExpAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7287:1: ( ( rule__UnaryExpression__ExpAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7288:1: ( rule__UnaryExpression__ExpAssignment_1 )

+            {

+             before(grammarAccess.getUnaryExpressionAccess().getExpAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7289:1: ( rule__UnaryExpression__ExpAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7289:2: rule__UnaryExpression__ExpAssignment_1

+            {

+            pushFollow(FOLLOW_rule__UnaryExpression__ExpAssignment_1_in_rule__UnaryExpression__Group__1__Impl15363);

+            rule__UnaryExpression__ExpAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getUnaryExpressionAccess().getExpAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UnaryExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__OperationCallExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7303:1: rule__OperationCallExpression__Group__0 : rule__OperationCallExpression__Group__0__Impl rule__OperationCallExpression__Group__1 ;

+    public final void rule__OperationCallExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7307:1: ( rule__OperationCallExpression__Group__0__Impl rule__OperationCallExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7308:2: rule__OperationCallExpression__Group__0__Impl rule__OperationCallExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__OperationCallExpression__Group__0__Impl_in_rule__OperationCallExpression__Group__015397);

+            rule__OperationCallExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__OperationCallExpression__Group__1_in_rule__OperationCallExpression__Group__015400);

+            rule__OperationCallExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__OperationCallExpression__Group__0"

+

+

+    // $ANTLR start "rule__OperationCallExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7315:1: rule__OperationCallExpression__Group__0__Impl : ( '.' ) ;

+    public final void rule__OperationCallExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7319:1: ( ( '.' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7320:1: ( '.' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7320:1: ( '.' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7321:1: '.'

+            {

+             before(grammarAccess.getOperationCallExpressionAccess().getFullStopKeyword_0()); 

+            match(input,77,FOLLOW_77_in_rule__OperationCallExpression__Group__0__Impl15428); 

+             after(grammarAccess.getOperationCallExpressionAccess().getFullStopKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__OperationCallExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__OperationCallExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7334:1: rule__OperationCallExpression__Group__1 : rule__OperationCallExpression__Group__1__Impl rule__OperationCallExpression__Group__2 ;

+    public final void rule__OperationCallExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7338:1: ( rule__OperationCallExpression__Group__1__Impl rule__OperationCallExpression__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7339:2: rule__OperationCallExpression__Group__1__Impl rule__OperationCallExpression__Group__2

+            {

+            pushFollow(FOLLOW_rule__OperationCallExpression__Group__1__Impl_in_rule__OperationCallExpression__Group__115459);

+            rule__OperationCallExpression__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__OperationCallExpression__Group__2_in_rule__OperationCallExpression__Group__115462);

+            rule__OperationCallExpression__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__OperationCallExpression__Group__1"

+

+

+    // $ANTLR start "rule__OperationCallExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7346:1: rule__OperationCallExpression__Group__1__Impl : ( ( rule__OperationCallExpression__OperationNameAssignment_1 ) ) ;

+    public final void rule__OperationCallExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7350:1: ( ( ( rule__OperationCallExpression__OperationNameAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7351:1: ( ( rule__OperationCallExpression__OperationNameAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7351:1: ( ( rule__OperationCallExpression__OperationNameAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7352:1: ( rule__OperationCallExpression__OperationNameAssignment_1 )

+            {

+             before(grammarAccess.getOperationCallExpressionAccess().getOperationNameAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7353:1: ( rule__OperationCallExpression__OperationNameAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7353:2: rule__OperationCallExpression__OperationNameAssignment_1

+            {

+            pushFollow(FOLLOW_rule__OperationCallExpression__OperationNameAssignment_1_in_rule__OperationCallExpression__Group__1__Impl15489);

+            rule__OperationCallExpression__OperationNameAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getOperationCallExpressionAccess().getOperationNameAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__OperationCallExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__OperationCallExpression__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7363:1: rule__OperationCallExpression__Group__2 : rule__OperationCallExpression__Group__2__Impl rule__OperationCallExpression__Group__3 ;

+    public final void rule__OperationCallExpression__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7367:1: ( rule__OperationCallExpression__Group__2__Impl rule__OperationCallExpression__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7368:2: rule__OperationCallExpression__Group__2__Impl rule__OperationCallExpression__Group__3

+            {

+            pushFollow(FOLLOW_rule__OperationCallExpression__Group__2__Impl_in_rule__OperationCallExpression__Group__215519);

+            rule__OperationCallExpression__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__OperationCallExpression__Group__3_in_rule__OperationCallExpression__Group__215522);

+            rule__OperationCallExpression__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__OperationCallExpression__Group__2"

+

+

+    // $ANTLR start "rule__OperationCallExpression__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7375:1: rule__OperationCallExpression__Group__2__Impl : ( ( rule__OperationCallExpression__TupleAssignment_2 ) ) ;

+    public final void rule__OperationCallExpression__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7379:1: ( ( ( rule__OperationCallExpression__TupleAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7380:1: ( ( rule__OperationCallExpression__TupleAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7380:1: ( ( rule__OperationCallExpression__TupleAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7381:1: ( rule__OperationCallExpression__TupleAssignment_2 )

+            {

+             before(grammarAccess.getOperationCallExpressionAccess().getTupleAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7382:1: ( rule__OperationCallExpression__TupleAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7382:2: rule__OperationCallExpression__TupleAssignment_2

+            {

+            pushFollow(FOLLOW_rule__OperationCallExpression__TupleAssignment_2_in_rule__OperationCallExpression__Group__2__Impl15549);

+            rule__OperationCallExpression__TupleAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getOperationCallExpressionAccess().getTupleAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__OperationCallExpression__Group__2__Impl"

+

+

+    // $ANTLR start "rule__OperationCallExpression__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7392:1: rule__OperationCallExpression__Group__3 : rule__OperationCallExpression__Group__3__Impl ;

+    public final void rule__OperationCallExpression__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7396:1: ( rule__OperationCallExpression__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7397:2: rule__OperationCallExpression__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__OperationCallExpression__Group__3__Impl_in_rule__OperationCallExpression__Group__315579);

+            rule__OperationCallExpression__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__OperationCallExpression__Group__3"

+

+

+    // $ANTLR start "rule__OperationCallExpression__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7403:1: rule__OperationCallExpression__Group__3__Impl : ( ( rule__OperationCallExpression__SuffixAssignment_3 )? ) ;

+    public final void rule__OperationCallExpression__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7407:1: ( ( ( rule__OperationCallExpression__SuffixAssignment_3 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7408:1: ( ( rule__OperationCallExpression__SuffixAssignment_3 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7408:1: ( ( rule__OperationCallExpression__SuffixAssignment_3 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7409:1: ( rule__OperationCallExpression__SuffixAssignment_3 )?

+            {

+             before(grammarAccess.getOperationCallExpressionAccess().getSuffixAssignment_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7410:1: ( rule__OperationCallExpression__SuffixAssignment_3 )?

+            int alt67=2;

+            int LA67_0 = input.LA(1);

+

+            if ( (LA67_0==77||LA67_0==80) ) {

+                alt67=1;

+            }

+            switch (alt67) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7410:2: rule__OperationCallExpression__SuffixAssignment_3

+                    {

+                    pushFollow(FOLLOW_rule__OperationCallExpression__SuffixAssignment_3_in_rule__OperationCallExpression__Group__3__Impl15606);

+                    rule__OperationCallExpression__SuffixAssignment_3();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getOperationCallExpressionAccess().getSuffixAssignment_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__OperationCallExpression__Group__3__Impl"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7428:1: rule__PropertyCallExpression__Group__0 : rule__PropertyCallExpression__Group__0__Impl rule__PropertyCallExpression__Group__1 ;

+    public final void rule__PropertyCallExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7432:1: ( rule__PropertyCallExpression__Group__0__Impl rule__PropertyCallExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7433:2: rule__PropertyCallExpression__Group__0__Impl rule__PropertyCallExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__PropertyCallExpression__Group__0__Impl_in_rule__PropertyCallExpression__Group__015645);

+            rule__PropertyCallExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__PropertyCallExpression__Group__1_in_rule__PropertyCallExpression__Group__015648);

+            rule__PropertyCallExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group__0"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7440:1: rule__PropertyCallExpression__Group__0__Impl : ( '.' ) ;

+    public final void rule__PropertyCallExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7444:1: ( ( '.' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7445:1: ( '.' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7445:1: ( '.' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7446:1: '.'

+            {

+             before(grammarAccess.getPropertyCallExpressionAccess().getFullStopKeyword_0()); 

+            match(input,77,FOLLOW_77_in_rule__PropertyCallExpression__Group__0__Impl15676); 

+             after(grammarAccess.getPropertyCallExpressionAccess().getFullStopKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7459:1: rule__PropertyCallExpression__Group__1 : rule__PropertyCallExpression__Group__1__Impl rule__PropertyCallExpression__Group__2 ;

+    public final void rule__PropertyCallExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7463:1: ( rule__PropertyCallExpression__Group__1__Impl rule__PropertyCallExpression__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7464:2: rule__PropertyCallExpression__Group__1__Impl rule__PropertyCallExpression__Group__2

+            {

+            pushFollow(FOLLOW_rule__PropertyCallExpression__Group__1__Impl_in_rule__PropertyCallExpression__Group__115707);

+            rule__PropertyCallExpression__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__PropertyCallExpression__Group__2_in_rule__PropertyCallExpression__Group__115710);

+            rule__PropertyCallExpression__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group__1"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7471:1: rule__PropertyCallExpression__Group__1__Impl : ( ( rule__PropertyCallExpression__PropertyNameAssignment_1 ) ) ;

+    public final void rule__PropertyCallExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7475:1: ( ( ( rule__PropertyCallExpression__PropertyNameAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7476:1: ( ( rule__PropertyCallExpression__PropertyNameAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7476:1: ( ( rule__PropertyCallExpression__PropertyNameAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7477:1: ( rule__PropertyCallExpression__PropertyNameAssignment_1 )

+            {

+             before(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7478:1: ( rule__PropertyCallExpression__PropertyNameAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7478:2: rule__PropertyCallExpression__PropertyNameAssignment_1

+            {

+            pushFollow(FOLLOW_rule__PropertyCallExpression__PropertyNameAssignment_1_in_rule__PropertyCallExpression__Group__1__Impl15737);

+            rule__PropertyCallExpression__PropertyNameAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7488:1: rule__PropertyCallExpression__Group__2 : rule__PropertyCallExpression__Group__2__Impl rule__PropertyCallExpression__Group__3 ;

+    public final void rule__PropertyCallExpression__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7492:1: ( rule__PropertyCallExpression__Group__2__Impl rule__PropertyCallExpression__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7493:2: rule__PropertyCallExpression__Group__2__Impl rule__PropertyCallExpression__Group__3

+            {

+            pushFollow(FOLLOW_rule__PropertyCallExpression__Group__2__Impl_in_rule__PropertyCallExpression__Group__215767);

+            rule__PropertyCallExpression__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__PropertyCallExpression__Group__3_in_rule__PropertyCallExpression__Group__215770);

+            rule__PropertyCallExpression__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group__2"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7500:1: rule__PropertyCallExpression__Group__2__Impl : ( ( rule__PropertyCallExpression__Group_2__0 )? ) ;

+    public final void rule__PropertyCallExpression__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7504:1: ( ( ( rule__PropertyCallExpression__Group_2__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7505:1: ( ( rule__PropertyCallExpression__Group_2__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7505:1: ( ( rule__PropertyCallExpression__Group_2__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7506:1: ( rule__PropertyCallExpression__Group_2__0 )?

+            {

+             before(grammarAccess.getPropertyCallExpressionAccess().getGroup_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7507:1: ( rule__PropertyCallExpression__Group_2__0 )?

+            int alt68=2;

+            int LA68_0 = input.LA(1);

+

+            if ( (LA68_0==78) ) {

+                int LA68_1 = input.LA(2);

+

+                if ( ((LA68_1>=RULE_INTEGERVALUE && LA68_1<=RULE_ID)||(LA68_1>=12 && LA68_1<=13)||(LA68_1>=25 && LA68_1<=27)||(LA68_1>=30 && LA68_1<=34)||LA68_1==68||(LA68_1>=83 && LA68_1<=86)) ) {

+                    alt68=1;

+                }

+            }

+            switch (alt68) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7507:2: rule__PropertyCallExpression__Group_2__0

+                    {

+                    pushFollow(FOLLOW_rule__PropertyCallExpression__Group_2__0_in_rule__PropertyCallExpression__Group__2__Impl15797);

+                    rule__PropertyCallExpression__Group_2__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getPropertyCallExpressionAccess().getGroup_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group__2__Impl"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7517:1: rule__PropertyCallExpression__Group__3 : rule__PropertyCallExpression__Group__3__Impl ;

+    public final void rule__PropertyCallExpression__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7521:1: ( rule__PropertyCallExpression__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7522:2: rule__PropertyCallExpression__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__PropertyCallExpression__Group__3__Impl_in_rule__PropertyCallExpression__Group__315828);

+            rule__PropertyCallExpression__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group__3"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7528:1: rule__PropertyCallExpression__Group__3__Impl : ( ( rule__PropertyCallExpression__SuffixAssignment_3 )? ) ;

+    public final void rule__PropertyCallExpression__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7532:1: ( ( ( rule__PropertyCallExpression__SuffixAssignment_3 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7533:1: ( ( rule__PropertyCallExpression__SuffixAssignment_3 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7533:1: ( ( rule__PropertyCallExpression__SuffixAssignment_3 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7534:1: ( rule__PropertyCallExpression__SuffixAssignment_3 )?

+            {

+             before(grammarAccess.getPropertyCallExpressionAccess().getSuffixAssignment_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7535:1: ( rule__PropertyCallExpression__SuffixAssignment_3 )?

+            int alt69=2;

+            int LA69_0 = input.LA(1);

+

+            if ( (LA69_0==77||LA69_0==80) ) {

+                alt69=1;

+            }

+            switch (alt69) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7535:2: rule__PropertyCallExpression__SuffixAssignment_3

+                    {

+                    pushFollow(FOLLOW_rule__PropertyCallExpression__SuffixAssignment_3_in_rule__PropertyCallExpression__Group__3__Impl15855);

+                    rule__PropertyCallExpression__SuffixAssignment_3();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getPropertyCallExpressionAccess().getSuffixAssignment_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group__3__Impl"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group_2__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7553:1: rule__PropertyCallExpression__Group_2__0 : rule__PropertyCallExpression__Group_2__0__Impl rule__PropertyCallExpression__Group_2__1 ;

+    public final void rule__PropertyCallExpression__Group_2__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7557:1: ( rule__PropertyCallExpression__Group_2__0__Impl rule__PropertyCallExpression__Group_2__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7558:2: rule__PropertyCallExpression__Group_2__0__Impl rule__PropertyCallExpression__Group_2__1

+            {

+            pushFollow(FOLLOW_rule__PropertyCallExpression__Group_2__0__Impl_in_rule__PropertyCallExpression__Group_2__015894);

+            rule__PropertyCallExpression__Group_2__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__PropertyCallExpression__Group_2__1_in_rule__PropertyCallExpression__Group_2__015897);

+            rule__PropertyCallExpression__Group_2__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group_2__0"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group_2__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7565:1: rule__PropertyCallExpression__Group_2__0__Impl : ( '[' ) ;

+    public final void rule__PropertyCallExpression__Group_2__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7569:1: ( ( '[' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7570:1: ( '[' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7570:1: ( '[' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7571:1: '['

+            {

+             before(grammarAccess.getPropertyCallExpressionAccess().getLeftSquareBracketKeyword_2_0()); 

+            match(input,78,FOLLOW_78_in_rule__PropertyCallExpression__Group_2__0__Impl15925); 

+             after(grammarAccess.getPropertyCallExpressionAccess().getLeftSquareBracketKeyword_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group_2__0__Impl"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group_2__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7584:1: rule__PropertyCallExpression__Group_2__1 : rule__PropertyCallExpression__Group_2__1__Impl rule__PropertyCallExpression__Group_2__2 ;

+    public final void rule__PropertyCallExpression__Group_2__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7588:1: ( rule__PropertyCallExpression__Group_2__1__Impl rule__PropertyCallExpression__Group_2__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7589:2: rule__PropertyCallExpression__Group_2__1__Impl rule__PropertyCallExpression__Group_2__2

+            {

+            pushFollow(FOLLOW_rule__PropertyCallExpression__Group_2__1__Impl_in_rule__PropertyCallExpression__Group_2__115956);

+            rule__PropertyCallExpression__Group_2__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__PropertyCallExpression__Group_2__2_in_rule__PropertyCallExpression__Group_2__115959);

+            rule__PropertyCallExpression__Group_2__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group_2__1"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group_2__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7596:1: rule__PropertyCallExpression__Group_2__1__Impl : ( ( rule__PropertyCallExpression__IndexAssignment_2_1 ) ) ;

+    public final void rule__PropertyCallExpression__Group_2__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7600:1: ( ( ( rule__PropertyCallExpression__IndexAssignment_2_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7601:1: ( ( rule__PropertyCallExpression__IndexAssignment_2_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7601:1: ( ( rule__PropertyCallExpression__IndexAssignment_2_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7602:1: ( rule__PropertyCallExpression__IndexAssignment_2_1 )

+            {

+             before(grammarAccess.getPropertyCallExpressionAccess().getIndexAssignment_2_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7603:1: ( rule__PropertyCallExpression__IndexAssignment_2_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7603:2: rule__PropertyCallExpression__IndexAssignment_2_1

+            {

+            pushFollow(FOLLOW_rule__PropertyCallExpression__IndexAssignment_2_1_in_rule__PropertyCallExpression__Group_2__1__Impl15986);

+            rule__PropertyCallExpression__IndexAssignment_2_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getPropertyCallExpressionAccess().getIndexAssignment_2_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group_2__1__Impl"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group_2__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7613:1: rule__PropertyCallExpression__Group_2__2 : rule__PropertyCallExpression__Group_2__2__Impl ;

+    public final void rule__PropertyCallExpression__Group_2__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7617:1: ( rule__PropertyCallExpression__Group_2__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7618:2: rule__PropertyCallExpression__Group_2__2__Impl

+            {

+            pushFollow(FOLLOW_rule__PropertyCallExpression__Group_2__2__Impl_in_rule__PropertyCallExpression__Group_2__216016);

+            rule__PropertyCallExpression__Group_2__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group_2__2"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__Group_2__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7624:1: rule__PropertyCallExpression__Group_2__2__Impl : ( ']' ) ;

+    public final void rule__PropertyCallExpression__Group_2__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7628:1: ( ( ']' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7629:1: ( ']' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7629:1: ( ']' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7630:1: ']'

+            {

+             before(grammarAccess.getPropertyCallExpressionAccess().getRightSquareBracketKeyword_2_2()); 

+            match(input,79,FOLLOW_79_in_rule__PropertyCallExpression__Group_2__2__Impl16044); 

+             after(grammarAccess.getPropertyCallExpressionAccess().getRightSquareBracketKeyword_2_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__Group_2__2__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7649:1: rule__LinkOperationExpression__Group__0 : rule__LinkOperationExpression__Group__0__Impl rule__LinkOperationExpression__Group__1 ;

+    public final void rule__LinkOperationExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7653:1: ( rule__LinkOperationExpression__Group__0__Impl rule__LinkOperationExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7654:2: rule__LinkOperationExpression__Group__0__Impl rule__LinkOperationExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__LinkOperationExpression__Group__0__Impl_in_rule__LinkOperationExpression__Group__016081);

+            rule__LinkOperationExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LinkOperationExpression__Group__1_in_rule__LinkOperationExpression__Group__016084);

+            rule__LinkOperationExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationExpression__Group__0"

+

+

+    // $ANTLR start "rule__LinkOperationExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7661:1: rule__LinkOperationExpression__Group__0__Impl : ( '.' ) ;

+    public final void rule__LinkOperationExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7665:1: ( ( '.' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7666:1: ( '.' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7666:1: ( '.' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7667:1: '.'

+            {

+             before(grammarAccess.getLinkOperationExpressionAccess().getFullStopKeyword_0()); 

+            match(input,77,FOLLOW_77_in_rule__LinkOperationExpression__Group__0__Impl16112); 

+             after(grammarAccess.getLinkOperationExpressionAccess().getFullStopKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7680:1: rule__LinkOperationExpression__Group__1 : rule__LinkOperationExpression__Group__1__Impl rule__LinkOperationExpression__Group__2 ;

+    public final void rule__LinkOperationExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7684:1: ( rule__LinkOperationExpression__Group__1__Impl rule__LinkOperationExpression__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7685:2: rule__LinkOperationExpression__Group__1__Impl rule__LinkOperationExpression__Group__2

+            {

+            pushFollow(FOLLOW_rule__LinkOperationExpression__Group__1__Impl_in_rule__LinkOperationExpression__Group__116143);

+            rule__LinkOperationExpression__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LinkOperationExpression__Group__2_in_rule__LinkOperationExpression__Group__116146);

+            rule__LinkOperationExpression__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationExpression__Group__1"

+

+

+    // $ANTLR start "rule__LinkOperationExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7692:1: rule__LinkOperationExpression__Group__1__Impl : ( ( rule__LinkOperationExpression__KindAssignment_1 ) ) ;

+    public final void rule__LinkOperationExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7696:1: ( ( ( rule__LinkOperationExpression__KindAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7697:1: ( ( rule__LinkOperationExpression__KindAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7697:1: ( ( rule__LinkOperationExpression__KindAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7698:1: ( rule__LinkOperationExpression__KindAssignment_1 )

+            {

+             before(grammarAccess.getLinkOperationExpressionAccess().getKindAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7699:1: ( rule__LinkOperationExpression__KindAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7699:2: rule__LinkOperationExpression__KindAssignment_1

+            {

+            pushFollow(FOLLOW_rule__LinkOperationExpression__KindAssignment_1_in_rule__LinkOperationExpression__Group__1__Impl16173);

+            rule__LinkOperationExpression__KindAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLinkOperationExpressionAccess().getKindAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationExpression__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7709:1: rule__LinkOperationExpression__Group__2 : rule__LinkOperationExpression__Group__2__Impl ;

+    public final void rule__LinkOperationExpression__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7713:1: ( rule__LinkOperationExpression__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7714:2: rule__LinkOperationExpression__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__LinkOperationExpression__Group__2__Impl_in_rule__LinkOperationExpression__Group__216203);

+            rule__LinkOperationExpression__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationExpression__Group__2"

+

+

+    // $ANTLR start "rule__LinkOperationExpression__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7720:1: rule__LinkOperationExpression__Group__2__Impl : ( ( rule__LinkOperationExpression__TupleAssignment_2 ) ) ;

+    public final void rule__LinkOperationExpression__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7724:1: ( ( ( rule__LinkOperationExpression__TupleAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7725:1: ( ( rule__LinkOperationExpression__TupleAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7725:1: ( ( rule__LinkOperationExpression__TupleAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7726:1: ( rule__LinkOperationExpression__TupleAssignment_2 )

+            {

+             before(grammarAccess.getLinkOperationExpressionAccess().getTupleAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7727:1: ( rule__LinkOperationExpression__TupleAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7727:2: rule__LinkOperationExpression__TupleAssignment_2

+            {

+            pushFollow(FOLLOW_rule__LinkOperationExpression__TupleAssignment_2_in_rule__LinkOperationExpression__Group__2__Impl16230);

+            rule__LinkOperationExpression__TupleAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLinkOperationExpressionAccess().getTupleAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationExpression__Group__2__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7743:1: rule__LinkOperationTuple__Group__0 : rule__LinkOperationTuple__Group__0__Impl rule__LinkOperationTuple__Group__1 ;

+    public final void rule__LinkOperationTuple__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7747:1: ( rule__LinkOperationTuple__Group__0__Impl rule__LinkOperationTuple__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7748:2: rule__LinkOperationTuple__Group__0__Impl rule__LinkOperationTuple__Group__1

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTuple__Group__0__Impl_in_rule__LinkOperationTuple__Group__016266);

+            rule__LinkOperationTuple__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LinkOperationTuple__Group__1_in_rule__LinkOperationTuple__Group__016269);

+            rule__LinkOperationTuple__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__Group__0"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7755:1: rule__LinkOperationTuple__Group__0__Impl : ( '(' ) ;

+    public final void rule__LinkOperationTuple__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7759:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7760:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7760:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7761:1: '('

+            {

+             before(grammarAccess.getLinkOperationTupleAccess().getLeftParenthesisKeyword_0()); 

+            match(input,68,FOLLOW_68_in_rule__LinkOperationTuple__Group__0__Impl16297); 

+             after(grammarAccess.getLinkOperationTupleAccess().getLeftParenthesisKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__Group__0__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7774:1: rule__LinkOperationTuple__Group__1 : rule__LinkOperationTuple__Group__1__Impl rule__LinkOperationTuple__Group__2 ;

+    public final void rule__LinkOperationTuple__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7778:1: ( rule__LinkOperationTuple__Group__1__Impl rule__LinkOperationTuple__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7779:2: rule__LinkOperationTuple__Group__1__Impl rule__LinkOperationTuple__Group__2

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTuple__Group__1__Impl_in_rule__LinkOperationTuple__Group__116328);

+            rule__LinkOperationTuple__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LinkOperationTuple__Group__2_in_rule__LinkOperationTuple__Group__116331);

+            rule__LinkOperationTuple__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__Group__1"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7786:1: rule__LinkOperationTuple__Group__1__Impl : ( ( rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1 ) ) ;

+    public final void rule__LinkOperationTuple__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7790:1: ( ( ( rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7791:1: ( ( rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7791:1: ( ( rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7792:1: ( rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1 )

+            {

+             before(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7793:1: ( rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7793:2: rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1_in_rule__LinkOperationTuple__Group__1__Impl16358);

+            rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__Group__1__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7803:1: rule__LinkOperationTuple__Group__2 : rule__LinkOperationTuple__Group__2__Impl rule__LinkOperationTuple__Group__3 ;

+    public final void rule__LinkOperationTuple__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7807:1: ( rule__LinkOperationTuple__Group__2__Impl rule__LinkOperationTuple__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7808:2: rule__LinkOperationTuple__Group__2__Impl rule__LinkOperationTuple__Group__3

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTuple__Group__2__Impl_in_rule__LinkOperationTuple__Group__216388);

+            rule__LinkOperationTuple__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LinkOperationTuple__Group__3_in_rule__LinkOperationTuple__Group__216391);

+            rule__LinkOperationTuple__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__Group__2"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7815:1: rule__LinkOperationTuple__Group__2__Impl : ( ( rule__LinkOperationTuple__Group_2__0 )* ) ;

+    public final void rule__LinkOperationTuple__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7819:1: ( ( ( rule__LinkOperationTuple__Group_2__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7820:1: ( ( rule__LinkOperationTuple__Group_2__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7820:1: ( ( rule__LinkOperationTuple__Group_2__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7821:1: ( rule__LinkOperationTuple__Group_2__0 )*

+            {

+             before(grammarAccess.getLinkOperationTupleAccess().getGroup_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7822:1: ( rule__LinkOperationTuple__Group_2__0 )*

+            loop70:

+            do {

+                int alt70=2;

+                int LA70_0 = input.LA(1);

+

+                if ( (LA70_0==66) ) {

+                    alt70=1;

+                }

+

+

+                switch (alt70) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7822:2: rule__LinkOperationTuple__Group_2__0

+            	    {

+            	    pushFollow(FOLLOW_rule__LinkOperationTuple__Group_2__0_in_rule__LinkOperationTuple__Group__2__Impl16418);

+            	    rule__LinkOperationTuple__Group_2__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop70;

+                }

+            } while (true);

+

+             after(grammarAccess.getLinkOperationTupleAccess().getGroup_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__Group__2__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7832:1: rule__LinkOperationTuple__Group__3 : rule__LinkOperationTuple__Group__3__Impl ;

+    public final void rule__LinkOperationTuple__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7836:1: ( rule__LinkOperationTuple__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7837:2: rule__LinkOperationTuple__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTuple__Group__3__Impl_in_rule__LinkOperationTuple__Group__316449);

+            rule__LinkOperationTuple__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__Group__3"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7843:1: rule__LinkOperationTuple__Group__3__Impl : ( ')' ) ;

+    public final void rule__LinkOperationTuple__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7847:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7848:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7848:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7849:1: ')'

+            {

+             before(grammarAccess.getLinkOperationTupleAccess().getRightParenthesisKeyword_3()); 

+            match(input,69,FOLLOW_69_in_rule__LinkOperationTuple__Group__3__Impl16477); 

+             after(grammarAccess.getLinkOperationTupleAccess().getRightParenthesisKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__Group__3__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__Group_2__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7870:1: rule__LinkOperationTuple__Group_2__0 : rule__LinkOperationTuple__Group_2__0__Impl rule__LinkOperationTuple__Group_2__1 ;

+    public final void rule__LinkOperationTuple__Group_2__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7874:1: ( rule__LinkOperationTuple__Group_2__0__Impl rule__LinkOperationTuple__Group_2__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7875:2: rule__LinkOperationTuple__Group_2__0__Impl rule__LinkOperationTuple__Group_2__1

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTuple__Group_2__0__Impl_in_rule__LinkOperationTuple__Group_2__016516);

+            rule__LinkOperationTuple__Group_2__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LinkOperationTuple__Group_2__1_in_rule__LinkOperationTuple__Group_2__016519);

+            rule__LinkOperationTuple__Group_2__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__Group_2__0"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__Group_2__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7882:1: rule__LinkOperationTuple__Group_2__0__Impl : ( ',' ) ;

+    public final void rule__LinkOperationTuple__Group_2__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7886:1: ( ( ',' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7887:1: ( ',' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7887:1: ( ',' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7888:1: ','

+            {

+             before(grammarAccess.getLinkOperationTupleAccess().getCommaKeyword_2_0()); 

+            match(input,66,FOLLOW_66_in_rule__LinkOperationTuple__Group_2__0__Impl16547); 

+             after(grammarAccess.getLinkOperationTupleAccess().getCommaKeyword_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__Group_2__0__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__Group_2__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7901:1: rule__LinkOperationTuple__Group_2__1 : rule__LinkOperationTuple__Group_2__1__Impl ;

+    public final void rule__LinkOperationTuple__Group_2__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7905:1: ( rule__LinkOperationTuple__Group_2__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7906:2: rule__LinkOperationTuple__Group_2__1__Impl

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTuple__Group_2__1__Impl_in_rule__LinkOperationTuple__Group_2__116578);

+            rule__LinkOperationTuple__Group_2__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__Group_2__1"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__Group_2__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7912:1: rule__LinkOperationTuple__Group_2__1__Impl : ( ( rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1 ) ) ;

+    public final void rule__LinkOperationTuple__Group_2__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7916:1: ( ( ( rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7917:1: ( ( rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7917:1: ( ( rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7918:1: ( rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1 )

+            {

+             before(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_2_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7919:1: ( rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7919:2: rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1_in_rule__LinkOperationTuple__Group_2__1__Impl16605);

+            rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementAssignment_2_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__Group_2__1__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7933:1: rule__LinkOperationTupleElement__Group__0 : rule__LinkOperationTupleElement__Group__0__Impl rule__LinkOperationTupleElement__Group__1 ;

+    public final void rule__LinkOperationTupleElement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7937:1: ( rule__LinkOperationTupleElement__Group__0__Impl rule__LinkOperationTupleElement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7938:2: rule__LinkOperationTupleElement__Group__0__Impl rule__LinkOperationTupleElement__Group__1

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group__0__Impl_in_rule__LinkOperationTupleElement__Group__016639);

+            rule__LinkOperationTupleElement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group__1_in_rule__LinkOperationTupleElement__Group__016642);

+            rule__LinkOperationTupleElement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group__0"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7945:1: rule__LinkOperationTupleElement__Group__0__Impl : ( ( rule__LinkOperationTupleElement__RoleAssignment_0 ) ) ;

+    public final void rule__LinkOperationTupleElement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7949:1: ( ( ( rule__LinkOperationTupleElement__RoleAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7950:1: ( ( rule__LinkOperationTupleElement__RoleAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7950:1: ( ( rule__LinkOperationTupleElement__RoleAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7951:1: ( rule__LinkOperationTupleElement__RoleAssignment_0 )

+            {

+             before(grammarAccess.getLinkOperationTupleElementAccess().getRoleAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7952:1: ( rule__LinkOperationTupleElement__RoleAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7952:2: rule__LinkOperationTupleElement__RoleAssignment_0

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__RoleAssignment_0_in_rule__LinkOperationTupleElement__Group__0__Impl16669);

+            rule__LinkOperationTupleElement__RoleAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLinkOperationTupleElementAccess().getRoleAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7962:1: rule__LinkOperationTupleElement__Group__1 : rule__LinkOperationTupleElement__Group__1__Impl rule__LinkOperationTupleElement__Group__2 ;

+    public final void rule__LinkOperationTupleElement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7966:1: ( rule__LinkOperationTupleElement__Group__1__Impl rule__LinkOperationTupleElement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7967:2: rule__LinkOperationTupleElement__Group__1__Impl rule__LinkOperationTupleElement__Group__2

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group__1__Impl_in_rule__LinkOperationTupleElement__Group__116699);

+            rule__LinkOperationTupleElement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group__2_in_rule__LinkOperationTupleElement__Group__116702);

+            rule__LinkOperationTupleElement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group__1"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7974:1: rule__LinkOperationTupleElement__Group__1__Impl : ( ( rule__LinkOperationTupleElement__Group_1__0 )? ) ;

+    public final void rule__LinkOperationTupleElement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7978:1: ( ( ( rule__LinkOperationTupleElement__Group_1__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7979:1: ( ( rule__LinkOperationTupleElement__Group_1__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7979:1: ( ( rule__LinkOperationTupleElement__Group_1__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7980:1: ( rule__LinkOperationTupleElement__Group_1__0 )?

+            {

+             before(grammarAccess.getLinkOperationTupleElementAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7981:1: ( rule__LinkOperationTupleElement__Group_1__0 )?

+            int alt71=2;

+            int LA71_0 = input.LA(1);

+

+            if ( (LA71_0==78) ) {

+                alt71=1;

+            }

+            switch (alt71) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7981:2: rule__LinkOperationTupleElement__Group_1__0

+                    {

+                    pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group_1__0_in_rule__LinkOperationTupleElement__Group__1__Impl16729);

+                    rule__LinkOperationTupleElement__Group_1__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getLinkOperationTupleElementAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7991:1: rule__LinkOperationTupleElement__Group__2 : rule__LinkOperationTupleElement__Group__2__Impl rule__LinkOperationTupleElement__Group__3 ;

+    public final void rule__LinkOperationTupleElement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7995:1: ( rule__LinkOperationTupleElement__Group__2__Impl rule__LinkOperationTupleElement__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:7996:2: rule__LinkOperationTupleElement__Group__2__Impl rule__LinkOperationTupleElement__Group__3

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group__2__Impl_in_rule__LinkOperationTupleElement__Group__216760);

+            rule__LinkOperationTupleElement__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group__3_in_rule__LinkOperationTupleElement__Group__216763);

+            rule__LinkOperationTupleElement__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group__2"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8003:1: rule__LinkOperationTupleElement__Group__2__Impl : ( '=>' ) ;

+    public final void rule__LinkOperationTupleElement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8007:1: ( ( '=>' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8008:1: ( '=>' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8008:1: ( '=>' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8009:1: '=>'

+            {

+             before(grammarAccess.getLinkOperationTupleElementAccess().getEqualsSignGreaterThanSignKeyword_2()); 

+            match(input,67,FOLLOW_67_in_rule__LinkOperationTupleElement__Group__2__Impl16791); 

+             after(grammarAccess.getLinkOperationTupleElementAccess().getEqualsSignGreaterThanSignKeyword_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8022:1: rule__LinkOperationTupleElement__Group__3 : rule__LinkOperationTupleElement__Group__3__Impl ;

+    public final void rule__LinkOperationTupleElement__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8026:1: ( rule__LinkOperationTupleElement__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8027:2: rule__LinkOperationTupleElement__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group__3__Impl_in_rule__LinkOperationTupleElement__Group__316822);

+            rule__LinkOperationTupleElement__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group__3"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8033:1: rule__LinkOperationTupleElement__Group__3__Impl : ( ( rule__LinkOperationTupleElement__ObjectAssignment_3 ) ) ;

+    public final void rule__LinkOperationTupleElement__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8037:1: ( ( ( rule__LinkOperationTupleElement__ObjectAssignment_3 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8038:1: ( ( rule__LinkOperationTupleElement__ObjectAssignment_3 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8038:1: ( ( rule__LinkOperationTupleElement__ObjectAssignment_3 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8039:1: ( rule__LinkOperationTupleElement__ObjectAssignment_3 )

+            {

+             before(grammarAccess.getLinkOperationTupleElementAccess().getObjectAssignment_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8040:1: ( rule__LinkOperationTupleElement__ObjectAssignment_3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8040:2: rule__LinkOperationTupleElement__ObjectAssignment_3

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__ObjectAssignment_3_in_rule__LinkOperationTupleElement__Group__3__Impl16849);

+            rule__LinkOperationTupleElement__ObjectAssignment_3();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLinkOperationTupleElementAccess().getObjectAssignment_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group__3__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8058:1: rule__LinkOperationTupleElement__Group_1__0 : rule__LinkOperationTupleElement__Group_1__0__Impl rule__LinkOperationTupleElement__Group_1__1 ;

+    public final void rule__LinkOperationTupleElement__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8062:1: ( rule__LinkOperationTupleElement__Group_1__0__Impl rule__LinkOperationTupleElement__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8063:2: rule__LinkOperationTupleElement__Group_1__0__Impl rule__LinkOperationTupleElement__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group_1__0__Impl_in_rule__LinkOperationTupleElement__Group_1__016887);

+            rule__LinkOperationTupleElement__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group_1__1_in_rule__LinkOperationTupleElement__Group_1__016890);

+            rule__LinkOperationTupleElement__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group_1__0"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8070:1: rule__LinkOperationTupleElement__Group_1__0__Impl : ( '[' ) ;

+    public final void rule__LinkOperationTupleElement__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8074:1: ( ( '[' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8075:1: ( '[' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8075:1: ( '[' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8076:1: '['

+            {

+             before(grammarAccess.getLinkOperationTupleElementAccess().getLeftSquareBracketKeyword_1_0()); 

+            match(input,78,FOLLOW_78_in_rule__LinkOperationTupleElement__Group_1__0__Impl16918); 

+             after(grammarAccess.getLinkOperationTupleElementAccess().getLeftSquareBracketKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8089:1: rule__LinkOperationTupleElement__Group_1__1 : rule__LinkOperationTupleElement__Group_1__1__Impl rule__LinkOperationTupleElement__Group_1__2 ;

+    public final void rule__LinkOperationTupleElement__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8093:1: ( rule__LinkOperationTupleElement__Group_1__1__Impl rule__LinkOperationTupleElement__Group_1__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8094:2: rule__LinkOperationTupleElement__Group_1__1__Impl rule__LinkOperationTupleElement__Group_1__2

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group_1__1__Impl_in_rule__LinkOperationTupleElement__Group_1__116949);

+            rule__LinkOperationTupleElement__Group_1__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group_1__2_in_rule__LinkOperationTupleElement__Group_1__116952);

+            rule__LinkOperationTupleElement__Group_1__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group_1__1"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8101:1: rule__LinkOperationTupleElement__Group_1__1__Impl : ( ( rule__LinkOperationTupleElement__RoleIndexAssignment_1_1 ) ) ;

+    public final void rule__LinkOperationTupleElement__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8105:1: ( ( ( rule__LinkOperationTupleElement__RoleIndexAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8106:1: ( ( rule__LinkOperationTupleElement__RoleIndexAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8106:1: ( ( rule__LinkOperationTupleElement__RoleIndexAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8107:1: ( rule__LinkOperationTupleElement__RoleIndexAssignment_1_1 )

+            {

+             before(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8108:1: ( rule__LinkOperationTupleElement__RoleIndexAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8108:2: rule__LinkOperationTupleElement__RoleIndexAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__RoleIndexAssignment_1_1_in_rule__LinkOperationTupleElement__Group_1__1__Impl16979);

+            rule__LinkOperationTupleElement__RoleIndexAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group_1__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8118:1: rule__LinkOperationTupleElement__Group_1__2 : rule__LinkOperationTupleElement__Group_1__2__Impl ;

+    public final void rule__LinkOperationTupleElement__Group_1__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8122:1: ( rule__LinkOperationTupleElement__Group_1__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8123:2: rule__LinkOperationTupleElement__Group_1__2__Impl

+            {

+            pushFollow(FOLLOW_rule__LinkOperationTupleElement__Group_1__2__Impl_in_rule__LinkOperationTupleElement__Group_1__217009);

+            rule__LinkOperationTupleElement__Group_1__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group_1__2"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__Group_1__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8129:1: rule__LinkOperationTupleElement__Group_1__2__Impl : ( ']' ) ;

+    public final void rule__LinkOperationTupleElement__Group_1__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8133:1: ( ( ']' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8134:1: ( ']' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8134:1: ( ']' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8135:1: ']'

+            {

+             before(grammarAccess.getLinkOperationTupleElementAccess().getRightSquareBracketKeyword_1_2()); 

+            match(input,79,FOLLOW_79_in_rule__LinkOperationTupleElement__Group_1__2__Impl17037); 

+             after(grammarAccess.getLinkOperationTupleElementAccess().getRightSquareBracketKeyword_1_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__Group_1__2__Impl"

+

+

+    // $ANTLR start "rule__SequenceOperationExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8154:1: rule__SequenceOperationExpression__Group__0 : rule__SequenceOperationExpression__Group__0__Impl rule__SequenceOperationExpression__Group__1 ;

+    public final void rule__SequenceOperationExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8158:1: ( rule__SequenceOperationExpression__Group__0__Impl rule__SequenceOperationExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8159:2: rule__SequenceOperationExpression__Group__0__Impl rule__SequenceOperationExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__SequenceOperationExpression__Group__0__Impl_in_rule__SequenceOperationExpression__Group__017074);

+            rule__SequenceOperationExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequenceOperationExpression__Group__1_in_rule__SequenceOperationExpression__Group__017077);

+            rule__SequenceOperationExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceOperationExpression__Group__0"

+

+

+    // $ANTLR start "rule__SequenceOperationExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8166:1: rule__SequenceOperationExpression__Group__0__Impl : ( '->' ) ;

+    public final void rule__SequenceOperationExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8170:1: ( ( '->' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8171:1: ( '->' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8171:1: ( '->' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8172:1: '->'

+            {

+             before(grammarAccess.getSequenceOperationExpressionAccess().getHyphenMinusGreaterThanSignKeyword_0()); 

+            match(input,80,FOLLOW_80_in_rule__SequenceOperationExpression__Group__0__Impl17105); 

+             after(grammarAccess.getSequenceOperationExpressionAccess().getHyphenMinusGreaterThanSignKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceOperationExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__SequenceOperationExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8185:1: rule__SequenceOperationExpression__Group__1 : rule__SequenceOperationExpression__Group__1__Impl rule__SequenceOperationExpression__Group__2 ;

+    public final void rule__SequenceOperationExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8189:1: ( rule__SequenceOperationExpression__Group__1__Impl rule__SequenceOperationExpression__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8190:2: rule__SequenceOperationExpression__Group__1__Impl rule__SequenceOperationExpression__Group__2

+            {

+            pushFollow(FOLLOW_rule__SequenceOperationExpression__Group__1__Impl_in_rule__SequenceOperationExpression__Group__117136);

+            rule__SequenceOperationExpression__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequenceOperationExpression__Group__2_in_rule__SequenceOperationExpression__Group__117139);

+            rule__SequenceOperationExpression__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceOperationExpression__Group__1"

+

+

+    // $ANTLR start "rule__SequenceOperationExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8197:1: rule__SequenceOperationExpression__Group__1__Impl : ( ( rule__SequenceOperationExpression__OperationNameAssignment_1 ) ) ;

+    public final void rule__SequenceOperationExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8201:1: ( ( ( rule__SequenceOperationExpression__OperationNameAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8202:1: ( ( rule__SequenceOperationExpression__OperationNameAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8202:1: ( ( rule__SequenceOperationExpression__OperationNameAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8203:1: ( rule__SequenceOperationExpression__OperationNameAssignment_1 )

+            {

+             before(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8204:1: ( rule__SequenceOperationExpression__OperationNameAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8204:2: rule__SequenceOperationExpression__OperationNameAssignment_1

+            {

+            pushFollow(FOLLOW_rule__SequenceOperationExpression__OperationNameAssignment_1_in_rule__SequenceOperationExpression__Group__1__Impl17166);

+            rule__SequenceOperationExpression__OperationNameAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceOperationExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__SequenceOperationExpression__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8214:1: rule__SequenceOperationExpression__Group__2 : rule__SequenceOperationExpression__Group__2__Impl rule__SequenceOperationExpression__Group__3 ;

+    public final void rule__SequenceOperationExpression__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8218:1: ( rule__SequenceOperationExpression__Group__2__Impl rule__SequenceOperationExpression__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8219:2: rule__SequenceOperationExpression__Group__2__Impl rule__SequenceOperationExpression__Group__3

+            {

+            pushFollow(FOLLOW_rule__SequenceOperationExpression__Group__2__Impl_in_rule__SequenceOperationExpression__Group__217196);

+            rule__SequenceOperationExpression__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequenceOperationExpression__Group__3_in_rule__SequenceOperationExpression__Group__217199);

+            rule__SequenceOperationExpression__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceOperationExpression__Group__2"

+

+

+    // $ANTLR start "rule__SequenceOperationExpression__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8226:1: rule__SequenceOperationExpression__Group__2__Impl : ( ( rule__SequenceOperationExpression__TupleAssignment_2 ) ) ;

+    public final void rule__SequenceOperationExpression__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8230:1: ( ( ( rule__SequenceOperationExpression__TupleAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8231:1: ( ( rule__SequenceOperationExpression__TupleAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8231:1: ( ( rule__SequenceOperationExpression__TupleAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8232:1: ( rule__SequenceOperationExpression__TupleAssignment_2 )

+            {

+             before(grammarAccess.getSequenceOperationExpressionAccess().getTupleAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8233:1: ( rule__SequenceOperationExpression__TupleAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8233:2: rule__SequenceOperationExpression__TupleAssignment_2

+            {

+            pushFollow(FOLLOW_rule__SequenceOperationExpression__TupleAssignment_2_in_rule__SequenceOperationExpression__Group__2__Impl17226);

+            rule__SequenceOperationExpression__TupleAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceOperationExpressionAccess().getTupleAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceOperationExpression__Group__2__Impl"

+

+

+    // $ANTLR start "rule__SequenceOperationExpression__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8243:1: rule__SequenceOperationExpression__Group__3 : rule__SequenceOperationExpression__Group__3__Impl ;

+    public final void rule__SequenceOperationExpression__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8247:1: ( rule__SequenceOperationExpression__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8248:2: rule__SequenceOperationExpression__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__SequenceOperationExpression__Group__3__Impl_in_rule__SequenceOperationExpression__Group__317256);

+            rule__SequenceOperationExpression__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceOperationExpression__Group__3"

+

+

+    // $ANTLR start "rule__SequenceOperationExpression__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8254:1: rule__SequenceOperationExpression__Group__3__Impl : ( ( rule__SequenceOperationExpression__SuffixAssignment_3 )? ) ;

+    public final void rule__SequenceOperationExpression__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8258:1: ( ( ( rule__SequenceOperationExpression__SuffixAssignment_3 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8259:1: ( ( rule__SequenceOperationExpression__SuffixAssignment_3 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8259:1: ( ( rule__SequenceOperationExpression__SuffixAssignment_3 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8260:1: ( rule__SequenceOperationExpression__SuffixAssignment_3 )?

+            {

+             before(grammarAccess.getSequenceOperationExpressionAccess().getSuffixAssignment_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8261:1: ( rule__SequenceOperationExpression__SuffixAssignment_3 )?

+            int alt72=2;

+            int LA72_0 = input.LA(1);

+

+            if ( (LA72_0==77||LA72_0==80) ) {

+                alt72=1;

+            }

+            switch (alt72) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8261:2: rule__SequenceOperationExpression__SuffixAssignment_3

+                    {

+                    pushFollow(FOLLOW_rule__SequenceOperationExpression__SuffixAssignment_3_in_rule__SequenceOperationExpression__Group__3__Impl17283);

+                    rule__SequenceOperationExpression__SuffixAssignment_3();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getSequenceOperationExpressionAccess().getSuffixAssignment_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceOperationExpression__Group__3__Impl"

+

+

+    // $ANTLR start "rule__SequenceReductionExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8279:1: rule__SequenceReductionExpression__Group__0 : rule__SequenceReductionExpression__Group__0__Impl rule__SequenceReductionExpression__Group__1 ;

+    public final void rule__SequenceReductionExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8283:1: ( rule__SequenceReductionExpression__Group__0__Impl rule__SequenceReductionExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8284:2: rule__SequenceReductionExpression__Group__0__Impl rule__SequenceReductionExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__SequenceReductionExpression__Group__0__Impl_in_rule__SequenceReductionExpression__Group__017322);

+            rule__SequenceReductionExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequenceReductionExpression__Group__1_in_rule__SequenceReductionExpression__Group__017325);

+            rule__SequenceReductionExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceReductionExpression__Group__0"

+

+

+    // $ANTLR start "rule__SequenceReductionExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8291:1: rule__SequenceReductionExpression__Group__0__Impl : ( '->' ) ;

+    public final void rule__SequenceReductionExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8295:1: ( ( '->' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8296:1: ( '->' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8296:1: ( '->' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8297:1: '->'

+            {

+             before(grammarAccess.getSequenceReductionExpressionAccess().getHyphenMinusGreaterThanSignKeyword_0()); 

+            match(input,80,FOLLOW_80_in_rule__SequenceReductionExpression__Group__0__Impl17353); 

+             after(grammarAccess.getSequenceReductionExpressionAccess().getHyphenMinusGreaterThanSignKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceReductionExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__SequenceReductionExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8310:1: rule__SequenceReductionExpression__Group__1 : rule__SequenceReductionExpression__Group__1__Impl rule__SequenceReductionExpression__Group__2 ;

+    public final void rule__SequenceReductionExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8314:1: ( rule__SequenceReductionExpression__Group__1__Impl rule__SequenceReductionExpression__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8315:2: rule__SequenceReductionExpression__Group__1__Impl rule__SequenceReductionExpression__Group__2

+            {

+            pushFollow(FOLLOW_rule__SequenceReductionExpression__Group__1__Impl_in_rule__SequenceReductionExpression__Group__117384);

+            rule__SequenceReductionExpression__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequenceReductionExpression__Group__2_in_rule__SequenceReductionExpression__Group__117387);

+            rule__SequenceReductionExpression__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceReductionExpression__Group__1"

+

+

+    // $ANTLR start "rule__SequenceReductionExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8322:1: rule__SequenceReductionExpression__Group__1__Impl : ( 'reduce' ) ;

+    public final void rule__SequenceReductionExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8326:1: ( ( 'reduce' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8327:1: ( 'reduce' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8327:1: ( 'reduce' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8328:1: 'reduce'

+            {

+             before(grammarAccess.getSequenceReductionExpressionAccess().getReduceKeyword_1()); 

+            match(input,81,FOLLOW_81_in_rule__SequenceReductionExpression__Group__1__Impl17415); 

+             after(grammarAccess.getSequenceReductionExpressionAccess().getReduceKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceReductionExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__SequenceReductionExpression__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8341:1: rule__SequenceReductionExpression__Group__2 : rule__SequenceReductionExpression__Group__2__Impl rule__SequenceReductionExpression__Group__3 ;

+    public final void rule__SequenceReductionExpression__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8345:1: ( rule__SequenceReductionExpression__Group__2__Impl rule__SequenceReductionExpression__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8346:2: rule__SequenceReductionExpression__Group__2__Impl rule__SequenceReductionExpression__Group__3

+            {

+            pushFollow(FOLLOW_rule__SequenceReductionExpression__Group__2__Impl_in_rule__SequenceReductionExpression__Group__217446);

+            rule__SequenceReductionExpression__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequenceReductionExpression__Group__3_in_rule__SequenceReductionExpression__Group__217449);

+            rule__SequenceReductionExpression__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceReductionExpression__Group__2"

+

+

+    // $ANTLR start "rule__SequenceReductionExpression__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8353:1: rule__SequenceReductionExpression__Group__2__Impl : ( ( rule__SequenceReductionExpression__IsOrderedAssignment_2 )? ) ;

+    public final void rule__SequenceReductionExpression__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8357:1: ( ( ( rule__SequenceReductionExpression__IsOrderedAssignment_2 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8358:1: ( ( rule__SequenceReductionExpression__IsOrderedAssignment_2 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8358:1: ( ( rule__SequenceReductionExpression__IsOrderedAssignment_2 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8359:1: ( rule__SequenceReductionExpression__IsOrderedAssignment_2 )?

+            {

+             before(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8360:1: ( rule__SequenceReductionExpression__IsOrderedAssignment_2 )?

+            int alt73=2;

+            int LA73_0 = input.LA(1);

+

+            if ( (LA73_0==113) ) {

+                alt73=1;

+            }

+            switch (alt73) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8360:2: rule__SequenceReductionExpression__IsOrderedAssignment_2

+                    {

+                    pushFollow(FOLLOW_rule__SequenceReductionExpression__IsOrderedAssignment_2_in_rule__SequenceReductionExpression__Group__2__Impl17476);

+                    rule__SequenceReductionExpression__IsOrderedAssignment_2();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceReductionExpression__Group__2__Impl"

+

+

+    // $ANTLR start "rule__SequenceReductionExpression__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8370:1: rule__SequenceReductionExpression__Group__3 : rule__SequenceReductionExpression__Group__3__Impl rule__SequenceReductionExpression__Group__4 ;

+    public final void rule__SequenceReductionExpression__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8374:1: ( rule__SequenceReductionExpression__Group__3__Impl rule__SequenceReductionExpression__Group__4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8375:2: rule__SequenceReductionExpression__Group__3__Impl rule__SequenceReductionExpression__Group__4

+            {

+            pushFollow(FOLLOW_rule__SequenceReductionExpression__Group__3__Impl_in_rule__SequenceReductionExpression__Group__317507);

+            rule__SequenceReductionExpression__Group__3__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequenceReductionExpression__Group__4_in_rule__SequenceReductionExpression__Group__317510);

+            rule__SequenceReductionExpression__Group__4();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceReductionExpression__Group__3"

+

+

+    // $ANTLR start "rule__SequenceReductionExpression__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8382:1: rule__SequenceReductionExpression__Group__3__Impl : ( ( rule__SequenceReductionExpression__BehaviorAssignment_3 ) ) ;

+    public final void rule__SequenceReductionExpression__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8386:1: ( ( ( rule__SequenceReductionExpression__BehaviorAssignment_3 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8387:1: ( ( rule__SequenceReductionExpression__BehaviorAssignment_3 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8387:1: ( ( rule__SequenceReductionExpression__BehaviorAssignment_3 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8388:1: ( rule__SequenceReductionExpression__BehaviorAssignment_3 )

+            {

+             before(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorAssignment_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8389:1: ( rule__SequenceReductionExpression__BehaviorAssignment_3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8389:2: rule__SequenceReductionExpression__BehaviorAssignment_3

+            {

+            pushFollow(FOLLOW_rule__SequenceReductionExpression__BehaviorAssignment_3_in_rule__SequenceReductionExpression__Group__3__Impl17537);

+            rule__SequenceReductionExpression__BehaviorAssignment_3();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorAssignment_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceReductionExpression__Group__3__Impl"

+

+

+    // $ANTLR start "rule__SequenceReductionExpression__Group__4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8399:1: rule__SequenceReductionExpression__Group__4 : rule__SequenceReductionExpression__Group__4__Impl ;

+    public final void rule__SequenceReductionExpression__Group__4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8403:1: ( rule__SequenceReductionExpression__Group__4__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8404:2: rule__SequenceReductionExpression__Group__4__Impl

+            {

+            pushFollow(FOLLOW_rule__SequenceReductionExpression__Group__4__Impl_in_rule__SequenceReductionExpression__Group__417567);

+            rule__SequenceReductionExpression__Group__4__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceReductionExpression__Group__4"

+

+

+    // $ANTLR start "rule__SequenceReductionExpression__Group__4__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8410:1: rule__SequenceReductionExpression__Group__4__Impl : ( ( rule__SequenceReductionExpression__SuffixAssignment_4 )? ) ;

+    public final void rule__SequenceReductionExpression__Group__4__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8414:1: ( ( ( rule__SequenceReductionExpression__SuffixAssignment_4 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8415:1: ( ( rule__SequenceReductionExpression__SuffixAssignment_4 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8415:1: ( ( rule__SequenceReductionExpression__SuffixAssignment_4 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8416:1: ( rule__SequenceReductionExpression__SuffixAssignment_4 )?

+            {

+             before(grammarAccess.getSequenceReductionExpressionAccess().getSuffixAssignment_4()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8417:1: ( rule__SequenceReductionExpression__SuffixAssignment_4 )?

+            int alt74=2;

+            int LA74_0 = input.LA(1);

+

+            if ( (LA74_0==77||LA74_0==80) ) {

+                alt74=1;

+            }

+            switch (alt74) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8417:2: rule__SequenceReductionExpression__SuffixAssignment_4

+                    {

+                    pushFollow(FOLLOW_rule__SequenceReductionExpression__SuffixAssignment_4_in_rule__SequenceReductionExpression__Group__4__Impl17594);

+                    rule__SequenceReductionExpression__SuffixAssignment_4();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getSequenceReductionExpressionAccess().getSuffixAssignment_4()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceReductionExpression__Group__4__Impl"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8437:1: rule__SelectOrRejectOperation__Group__0 : rule__SelectOrRejectOperation__Group__0__Impl rule__SelectOrRejectOperation__Group__1 ;

+    public final void rule__SelectOrRejectOperation__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8441:1: ( rule__SelectOrRejectOperation__Group__0__Impl rule__SelectOrRejectOperation__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8442:2: rule__SelectOrRejectOperation__Group__0__Impl rule__SelectOrRejectOperation__Group__1

+            {

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__0__Impl_in_rule__SelectOrRejectOperation__Group__017635);

+            rule__SelectOrRejectOperation__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__1_in_rule__SelectOrRejectOperation__Group__017638);

+            rule__SelectOrRejectOperation__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__0"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8449:1: rule__SelectOrRejectOperation__Group__0__Impl : ( '->' ) ;

+    public final void rule__SelectOrRejectOperation__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8453:1: ( ( '->' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8454:1: ( '->' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8454:1: ( '->' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8455:1: '->'

+            {

+             before(grammarAccess.getSelectOrRejectOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); 

+            match(input,80,FOLLOW_80_in_rule__SelectOrRejectOperation__Group__0__Impl17666); 

+             after(grammarAccess.getSelectOrRejectOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__0__Impl"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8468:1: rule__SelectOrRejectOperation__Group__1 : rule__SelectOrRejectOperation__Group__1__Impl rule__SelectOrRejectOperation__Group__2 ;

+    public final void rule__SelectOrRejectOperation__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8472:1: ( rule__SelectOrRejectOperation__Group__1__Impl rule__SelectOrRejectOperation__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8473:2: rule__SelectOrRejectOperation__Group__1__Impl rule__SelectOrRejectOperation__Group__2

+            {

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__1__Impl_in_rule__SelectOrRejectOperation__Group__117697);

+            rule__SelectOrRejectOperation__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__2_in_rule__SelectOrRejectOperation__Group__117700);

+            rule__SelectOrRejectOperation__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__1"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8480:1: rule__SelectOrRejectOperation__Group__1__Impl : ( ( rule__SelectOrRejectOperation__OpAssignment_1 ) ) ;

+    public final void rule__SelectOrRejectOperation__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8484:1: ( ( ( rule__SelectOrRejectOperation__OpAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8485:1: ( ( rule__SelectOrRejectOperation__OpAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8485:1: ( ( rule__SelectOrRejectOperation__OpAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8486:1: ( rule__SelectOrRejectOperation__OpAssignment_1 )

+            {

+             before(grammarAccess.getSelectOrRejectOperationAccess().getOpAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8487:1: ( rule__SelectOrRejectOperation__OpAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8487:2: rule__SelectOrRejectOperation__OpAssignment_1

+            {

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__OpAssignment_1_in_rule__SelectOrRejectOperation__Group__1__Impl17727);

+            rule__SelectOrRejectOperation__OpAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSelectOrRejectOperationAccess().getOpAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__1__Impl"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8497:1: rule__SelectOrRejectOperation__Group__2 : rule__SelectOrRejectOperation__Group__2__Impl rule__SelectOrRejectOperation__Group__3 ;

+    public final void rule__SelectOrRejectOperation__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8501:1: ( rule__SelectOrRejectOperation__Group__2__Impl rule__SelectOrRejectOperation__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8502:2: rule__SelectOrRejectOperation__Group__2__Impl rule__SelectOrRejectOperation__Group__3

+            {

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__2__Impl_in_rule__SelectOrRejectOperation__Group__217757);

+            rule__SelectOrRejectOperation__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__3_in_rule__SelectOrRejectOperation__Group__217760);

+            rule__SelectOrRejectOperation__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__2"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8509:1: rule__SelectOrRejectOperation__Group__2__Impl : ( ( rule__SelectOrRejectOperation__NameAssignment_2 ) ) ;

+    public final void rule__SelectOrRejectOperation__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8513:1: ( ( ( rule__SelectOrRejectOperation__NameAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8514:1: ( ( rule__SelectOrRejectOperation__NameAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8514:1: ( ( rule__SelectOrRejectOperation__NameAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8515:1: ( rule__SelectOrRejectOperation__NameAssignment_2 )

+            {

+             before(grammarAccess.getSelectOrRejectOperationAccess().getNameAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8516:1: ( rule__SelectOrRejectOperation__NameAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8516:2: rule__SelectOrRejectOperation__NameAssignment_2

+            {

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__NameAssignment_2_in_rule__SelectOrRejectOperation__Group__2__Impl17787);

+            rule__SelectOrRejectOperation__NameAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSelectOrRejectOperationAccess().getNameAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__2__Impl"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8526:1: rule__SelectOrRejectOperation__Group__3 : rule__SelectOrRejectOperation__Group__3__Impl rule__SelectOrRejectOperation__Group__4 ;

+    public final void rule__SelectOrRejectOperation__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8530:1: ( rule__SelectOrRejectOperation__Group__3__Impl rule__SelectOrRejectOperation__Group__4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8531:2: rule__SelectOrRejectOperation__Group__3__Impl rule__SelectOrRejectOperation__Group__4

+            {

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__3__Impl_in_rule__SelectOrRejectOperation__Group__317817);

+            rule__SelectOrRejectOperation__Group__3__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__4_in_rule__SelectOrRejectOperation__Group__317820);

+            rule__SelectOrRejectOperation__Group__4();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__3"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8538:1: rule__SelectOrRejectOperation__Group__3__Impl : ( '(' ) ;

+    public final void rule__SelectOrRejectOperation__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8542:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8543:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8543:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8544:1: '('

+            {

+             before(grammarAccess.getSelectOrRejectOperationAccess().getLeftParenthesisKeyword_3()); 

+            match(input,68,FOLLOW_68_in_rule__SelectOrRejectOperation__Group__3__Impl17848); 

+             after(grammarAccess.getSelectOrRejectOperationAccess().getLeftParenthesisKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__3__Impl"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8557:1: rule__SelectOrRejectOperation__Group__4 : rule__SelectOrRejectOperation__Group__4__Impl rule__SelectOrRejectOperation__Group__5 ;

+    public final void rule__SelectOrRejectOperation__Group__4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8561:1: ( rule__SelectOrRejectOperation__Group__4__Impl rule__SelectOrRejectOperation__Group__5 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8562:2: rule__SelectOrRejectOperation__Group__4__Impl rule__SelectOrRejectOperation__Group__5

+            {

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__4__Impl_in_rule__SelectOrRejectOperation__Group__417879);

+            rule__SelectOrRejectOperation__Group__4__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__5_in_rule__SelectOrRejectOperation__Group__417882);

+            rule__SelectOrRejectOperation__Group__5();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__4"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__4__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8569:1: rule__SelectOrRejectOperation__Group__4__Impl : ( ( rule__SelectOrRejectOperation__ExprAssignment_4 ) ) ;

+    public final void rule__SelectOrRejectOperation__Group__4__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8573:1: ( ( ( rule__SelectOrRejectOperation__ExprAssignment_4 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8574:1: ( ( rule__SelectOrRejectOperation__ExprAssignment_4 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8574:1: ( ( rule__SelectOrRejectOperation__ExprAssignment_4 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8575:1: ( rule__SelectOrRejectOperation__ExprAssignment_4 )

+            {

+             before(grammarAccess.getSelectOrRejectOperationAccess().getExprAssignment_4()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8576:1: ( rule__SelectOrRejectOperation__ExprAssignment_4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8576:2: rule__SelectOrRejectOperation__ExprAssignment_4

+            {

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__ExprAssignment_4_in_rule__SelectOrRejectOperation__Group__4__Impl17909);

+            rule__SelectOrRejectOperation__ExprAssignment_4();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSelectOrRejectOperationAccess().getExprAssignment_4()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__4__Impl"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__5"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8586:1: rule__SelectOrRejectOperation__Group__5 : rule__SelectOrRejectOperation__Group__5__Impl rule__SelectOrRejectOperation__Group__6 ;

+    public final void rule__SelectOrRejectOperation__Group__5() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8590:1: ( rule__SelectOrRejectOperation__Group__5__Impl rule__SelectOrRejectOperation__Group__6 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8591:2: rule__SelectOrRejectOperation__Group__5__Impl rule__SelectOrRejectOperation__Group__6

+            {

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__5__Impl_in_rule__SelectOrRejectOperation__Group__517939);

+            rule__SelectOrRejectOperation__Group__5__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__6_in_rule__SelectOrRejectOperation__Group__517942);

+            rule__SelectOrRejectOperation__Group__6();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__5"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__5__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8598:1: rule__SelectOrRejectOperation__Group__5__Impl : ( ')' ) ;

+    public final void rule__SelectOrRejectOperation__Group__5__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8602:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8603:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8603:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8604:1: ')'

+            {

+             before(grammarAccess.getSelectOrRejectOperationAccess().getRightParenthesisKeyword_5()); 

+            match(input,69,FOLLOW_69_in_rule__SelectOrRejectOperation__Group__5__Impl17970); 

+             after(grammarAccess.getSelectOrRejectOperationAccess().getRightParenthesisKeyword_5()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__5__Impl"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8617:1: rule__SelectOrRejectOperation__Group__6 : rule__SelectOrRejectOperation__Group__6__Impl ;

+    public final void rule__SelectOrRejectOperation__Group__6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8621:1: ( rule__SelectOrRejectOperation__Group__6__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8622:2: rule__SelectOrRejectOperation__Group__6__Impl

+            {

+            pushFollow(FOLLOW_rule__SelectOrRejectOperation__Group__6__Impl_in_rule__SelectOrRejectOperation__Group__618001);

+            rule__SelectOrRejectOperation__Group__6__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__6"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__Group__6__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8628:1: rule__SelectOrRejectOperation__Group__6__Impl : ( ( rule__SelectOrRejectOperation__SuffixAssignment_6 )? ) ;

+    public final void rule__SelectOrRejectOperation__Group__6__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8632:1: ( ( ( rule__SelectOrRejectOperation__SuffixAssignment_6 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8633:1: ( ( rule__SelectOrRejectOperation__SuffixAssignment_6 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8633:1: ( ( rule__SelectOrRejectOperation__SuffixAssignment_6 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8634:1: ( rule__SelectOrRejectOperation__SuffixAssignment_6 )?

+            {

+             before(grammarAccess.getSelectOrRejectOperationAccess().getSuffixAssignment_6()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8635:1: ( rule__SelectOrRejectOperation__SuffixAssignment_6 )?

+            int alt75=2;

+            int LA75_0 = input.LA(1);

+

+            if ( (LA75_0==77||LA75_0==80) ) {

+                alt75=1;

+            }

+            switch (alt75) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8635:2: rule__SelectOrRejectOperation__SuffixAssignment_6

+                    {

+                    pushFollow(FOLLOW_rule__SelectOrRejectOperation__SuffixAssignment_6_in_rule__SelectOrRejectOperation__Group__6__Impl18028);

+                    rule__SelectOrRejectOperation__SuffixAssignment_6();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getSelectOrRejectOperationAccess().getSuffixAssignment_6()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__Group__6__Impl"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8659:1: rule__CollectOrIterateOperation__Group__0 : rule__CollectOrIterateOperation__Group__0__Impl rule__CollectOrIterateOperation__Group__1 ;

+    public final void rule__CollectOrIterateOperation__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8663:1: ( rule__CollectOrIterateOperation__Group__0__Impl rule__CollectOrIterateOperation__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8664:2: rule__CollectOrIterateOperation__Group__0__Impl rule__CollectOrIterateOperation__Group__1

+            {

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__0__Impl_in_rule__CollectOrIterateOperation__Group__018073);

+            rule__CollectOrIterateOperation__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__1_in_rule__CollectOrIterateOperation__Group__018076);

+            rule__CollectOrIterateOperation__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__0"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8671:1: rule__CollectOrIterateOperation__Group__0__Impl : ( '->' ) ;

+    public final void rule__CollectOrIterateOperation__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8675:1: ( ( '->' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8676:1: ( '->' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8676:1: ( '->' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8677:1: '->'

+            {

+             before(grammarAccess.getCollectOrIterateOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); 

+            match(input,80,FOLLOW_80_in_rule__CollectOrIterateOperation__Group__0__Impl18104); 

+             after(grammarAccess.getCollectOrIterateOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__0__Impl"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8690:1: rule__CollectOrIterateOperation__Group__1 : rule__CollectOrIterateOperation__Group__1__Impl rule__CollectOrIterateOperation__Group__2 ;

+    public final void rule__CollectOrIterateOperation__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8694:1: ( rule__CollectOrIterateOperation__Group__1__Impl rule__CollectOrIterateOperation__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8695:2: rule__CollectOrIterateOperation__Group__1__Impl rule__CollectOrIterateOperation__Group__2

+            {

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__1__Impl_in_rule__CollectOrIterateOperation__Group__118135);

+            rule__CollectOrIterateOperation__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__2_in_rule__CollectOrIterateOperation__Group__118138);

+            rule__CollectOrIterateOperation__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__1"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8702:1: rule__CollectOrIterateOperation__Group__1__Impl : ( ( rule__CollectOrIterateOperation__OpAssignment_1 ) ) ;

+    public final void rule__CollectOrIterateOperation__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8706:1: ( ( ( rule__CollectOrIterateOperation__OpAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8707:1: ( ( rule__CollectOrIterateOperation__OpAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8707:1: ( ( rule__CollectOrIterateOperation__OpAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8708:1: ( rule__CollectOrIterateOperation__OpAssignment_1 )

+            {

+             before(grammarAccess.getCollectOrIterateOperationAccess().getOpAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8709:1: ( rule__CollectOrIterateOperation__OpAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8709:2: rule__CollectOrIterateOperation__OpAssignment_1

+            {

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__OpAssignment_1_in_rule__CollectOrIterateOperation__Group__1__Impl18165);

+            rule__CollectOrIterateOperation__OpAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getCollectOrIterateOperationAccess().getOpAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__1__Impl"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8719:1: rule__CollectOrIterateOperation__Group__2 : rule__CollectOrIterateOperation__Group__2__Impl rule__CollectOrIterateOperation__Group__3 ;

+    public final void rule__CollectOrIterateOperation__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8723:1: ( rule__CollectOrIterateOperation__Group__2__Impl rule__CollectOrIterateOperation__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8724:2: rule__CollectOrIterateOperation__Group__2__Impl rule__CollectOrIterateOperation__Group__3

+            {

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__2__Impl_in_rule__CollectOrIterateOperation__Group__218195);

+            rule__CollectOrIterateOperation__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__3_in_rule__CollectOrIterateOperation__Group__218198);

+            rule__CollectOrIterateOperation__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__2"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8731:1: rule__CollectOrIterateOperation__Group__2__Impl : ( ( rule__CollectOrIterateOperation__NameAssignment_2 ) ) ;

+    public final void rule__CollectOrIterateOperation__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8735:1: ( ( ( rule__CollectOrIterateOperation__NameAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8736:1: ( ( rule__CollectOrIterateOperation__NameAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8736:1: ( ( rule__CollectOrIterateOperation__NameAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8737:1: ( rule__CollectOrIterateOperation__NameAssignment_2 )

+            {

+             before(grammarAccess.getCollectOrIterateOperationAccess().getNameAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8738:1: ( rule__CollectOrIterateOperation__NameAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8738:2: rule__CollectOrIterateOperation__NameAssignment_2

+            {

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__NameAssignment_2_in_rule__CollectOrIterateOperation__Group__2__Impl18225);

+            rule__CollectOrIterateOperation__NameAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getCollectOrIterateOperationAccess().getNameAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__2__Impl"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8748:1: rule__CollectOrIterateOperation__Group__3 : rule__CollectOrIterateOperation__Group__3__Impl rule__CollectOrIterateOperation__Group__4 ;

+    public final void rule__CollectOrIterateOperation__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8752:1: ( rule__CollectOrIterateOperation__Group__3__Impl rule__CollectOrIterateOperation__Group__4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8753:2: rule__CollectOrIterateOperation__Group__3__Impl rule__CollectOrIterateOperation__Group__4

+            {

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__3__Impl_in_rule__CollectOrIterateOperation__Group__318255);

+            rule__CollectOrIterateOperation__Group__3__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__4_in_rule__CollectOrIterateOperation__Group__318258);

+            rule__CollectOrIterateOperation__Group__4();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__3"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8760:1: rule__CollectOrIterateOperation__Group__3__Impl : ( '(' ) ;

+    public final void rule__CollectOrIterateOperation__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8764:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8765:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8765:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8766:1: '('

+            {

+             before(grammarAccess.getCollectOrIterateOperationAccess().getLeftParenthesisKeyword_3()); 

+            match(input,68,FOLLOW_68_in_rule__CollectOrIterateOperation__Group__3__Impl18286); 

+             after(grammarAccess.getCollectOrIterateOperationAccess().getLeftParenthesisKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__3__Impl"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8779:1: rule__CollectOrIterateOperation__Group__4 : rule__CollectOrIterateOperation__Group__4__Impl rule__CollectOrIterateOperation__Group__5 ;

+    public final void rule__CollectOrIterateOperation__Group__4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8783:1: ( rule__CollectOrIterateOperation__Group__4__Impl rule__CollectOrIterateOperation__Group__5 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8784:2: rule__CollectOrIterateOperation__Group__4__Impl rule__CollectOrIterateOperation__Group__5

+            {

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__4__Impl_in_rule__CollectOrIterateOperation__Group__418317);

+            rule__CollectOrIterateOperation__Group__4__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__5_in_rule__CollectOrIterateOperation__Group__418320);

+            rule__CollectOrIterateOperation__Group__5();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__4"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__4__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8791:1: rule__CollectOrIterateOperation__Group__4__Impl : ( ( rule__CollectOrIterateOperation__ExprAssignment_4 ) ) ;

+    public final void rule__CollectOrIterateOperation__Group__4__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8795:1: ( ( ( rule__CollectOrIterateOperation__ExprAssignment_4 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8796:1: ( ( rule__CollectOrIterateOperation__ExprAssignment_4 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8796:1: ( ( rule__CollectOrIterateOperation__ExprAssignment_4 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8797:1: ( rule__CollectOrIterateOperation__ExprAssignment_4 )

+            {

+             before(grammarAccess.getCollectOrIterateOperationAccess().getExprAssignment_4()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8798:1: ( rule__CollectOrIterateOperation__ExprAssignment_4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8798:2: rule__CollectOrIterateOperation__ExprAssignment_4

+            {

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__ExprAssignment_4_in_rule__CollectOrIterateOperation__Group__4__Impl18347);

+            rule__CollectOrIterateOperation__ExprAssignment_4();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getCollectOrIterateOperationAccess().getExprAssignment_4()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__4__Impl"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__5"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8808:1: rule__CollectOrIterateOperation__Group__5 : rule__CollectOrIterateOperation__Group__5__Impl rule__CollectOrIterateOperation__Group__6 ;

+    public final void rule__CollectOrIterateOperation__Group__5() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8812:1: ( rule__CollectOrIterateOperation__Group__5__Impl rule__CollectOrIterateOperation__Group__6 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8813:2: rule__CollectOrIterateOperation__Group__5__Impl rule__CollectOrIterateOperation__Group__6

+            {

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__5__Impl_in_rule__CollectOrIterateOperation__Group__518377);

+            rule__CollectOrIterateOperation__Group__5__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__6_in_rule__CollectOrIterateOperation__Group__518380);

+            rule__CollectOrIterateOperation__Group__6();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__5"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__5__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8820:1: rule__CollectOrIterateOperation__Group__5__Impl : ( ')' ) ;

+    public final void rule__CollectOrIterateOperation__Group__5__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8824:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8825:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8825:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8826:1: ')'

+            {

+             before(grammarAccess.getCollectOrIterateOperationAccess().getRightParenthesisKeyword_5()); 

+            match(input,69,FOLLOW_69_in_rule__CollectOrIterateOperation__Group__5__Impl18408); 

+             after(grammarAccess.getCollectOrIterateOperationAccess().getRightParenthesisKeyword_5()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__5__Impl"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8839:1: rule__CollectOrIterateOperation__Group__6 : rule__CollectOrIterateOperation__Group__6__Impl ;

+    public final void rule__CollectOrIterateOperation__Group__6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8843:1: ( rule__CollectOrIterateOperation__Group__6__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8844:2: rule__CollectOrIterateOperation__Group__6__Impl

+            {

+            pushFollow(FOLLOW_rule__CollectOrIterateOperation__Group__6__Impl_in_rule__CollectOrIterateOperation__Group__618439);

+            rule__CollectOrIterateOperation__Group__6__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__6"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__Group__6__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8850:1: rule__CollectOrIterateOperation__Group__6__Impl : ( ( rule__CollectOrIterateOperation__SuffixAssignment_6 )? ) ;

+    public final void rule__CollectOrIterateOperation__Group__6__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8854:1: ( ( ( rule__CollectOrIterateOperation__SuffixAssignment_6 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8855:1: ( ( rule__CollectOrIterateOperation__SuffixAssignment_6 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8855:1: ( ( rule__CollectOrIterateOperation__SuffixAssignment_6 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8856:1: ( rule__CollectOrIterateOperation__SuffixAssignment_6 )?

+            {

+             before(grammarAccess.getCollectOrIterateOperationAccess().getSuffixAssignment_6()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8857:1: ( rule__CollectOrIterateOperation__SuffixAssignment_6 )?

+            int alt76=2;

+            int LA76_0 = input.LA(1);

+

+            if ( (LA76_0==77||LA76_0==80) ) {

+                alt76=1;

+            }

+            switch (alt76) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8857:2: rule__CollectOrIterateOperation__SuffixAssignment_6

+                    {

+                    pushFollow(FOLLOW_rule__CollectOrIterateOperation__SuffixAssignment_6_in_rule__CollectOrIterateOperation__Group__6__Impl18466);

+                    rule__CollectOrIterateOperation__SuffixAssignment_6();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getCollectOrIterateOperationAccess().getSuffixAssignment_6()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__Group__6__Impl"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8881:1: rule__ForAllOrExistsOrOneOperation__Group__0 : rule__ForAllOrExistsOrOneOperation__Group__0__Impl rule__ForAllOrExistsOrOneOperation__Group__1 ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8885:1: ( rule__ForAllOrExistsOrOneOperation__Group__0__Impl rule__ForAllOrExistsOrOneOperation__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8886:2: rule__ForAllOrExistsOrOneOperation__Group__0__Impl rule__ForAllOrExistsOrOneOperation__Group__1

+            {

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__0__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__018511);

+            rule__ForAllOrExistsOrOneOperation__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__1_in_rule__ForAllOrExistsOrOneOperation__Group__018514);

+            rule__ForAllOrExistsOrOneOperation__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__0"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8893:1: rule__ForAllOrExistsOrOneOperation__Group__0__Impl : ( '->' ) ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8897:1: ( ( '->' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8898:1: ( '->' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8898:1: ( '->' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8899:1: '->'

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); 

+            match(input,80,FOLLOW_80_in_rule__ForAllOrExistsOrOneOperation__Group__0__Impl18542); 

+             after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8912:1: rule__ForAllOrExistsOrOneOperation__Group__1 : rule__ForAllOrExistsOrOneOperation__Group__1__Impl rule__ForAllOrExistsOrOneOperation__Group__2 ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8916:1: ( rule__ForAllOrExistsOrOneOperation__Group__1__Impl rule__ForAllOrExistsOrOneOperation__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8917:2: rule__ForAllOrExistsOrOneOperation__Group__1__Impl rule__ForAllOrExistsOrOneOperation__Group__2

+            {

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__1__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__118573);

+            rule__ForAllOrExistsOrOneOperation__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__2_in_rule__ForAllOrExistsOrOneOperation__Group__118576);

+            rule__ForAllOrExistsOrOneOperation__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__1"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8924:1: rule__ForAllOrExistsOrOneOperation__Group__1__Impl : ( ( rule__ForAllOrExistsOrOneOperation__OpAssignment_1 ) ) ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8928:1: ( ( ( rule__ForAllOrExistsOrOneOperation__OpAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8929:1: ( ( rule__ForAllOrExistsOrOneOperation__OpAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8929:1: ( ( rule__ForAllOrExistsOrOneOperation__OpAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8930:1: ( rule__ForAllOrExistsOrOneOperation__OpAssignment_1 )

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8931:1: ( rule__ForAllOrExistsOrOneOperation__OpAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8931:2: rule__ForAllOrExistsOrOneOperation__OpAssignment_1

+            {

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__OpAssignment_1_in_rule__ForAllOrExistsOrOneOperation__Group__1__Impl18603);

+            rule__ForAllOrExistsOrOneOperation__OpAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8941:1: rule__ForAllOrExistsOrOneOperation__Group__2 : rule__ForAllOrExistsOrOneOperation__Group__2__Impl rule__ForAllOrExistsOrOneOperation__Group__3 ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8945:1: ( rule__ForAllOrExistsOrOneOperation__Group__2__Impl rule__ForAllOrExistsOrOneOperation__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8946:2: rule__ForAllOrExistsOrOneOperation__Group__2__Impl rule__ForAllOrExistsOrOneOperation__Group__3

+            {

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__2__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__218633);

+            rule__ForAllOrExistsOrOneOperation__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__3_in_rule__ForAllOrExistsOrOneOperation__Group__218636);

+            rule__ForAllOrExistsOrOneOperation__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__2"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8953:1: rule__ForAllOrExistsOrOneOperation__Group__2__Impl : ( ( rule__ForAllOrExistsOrOneOperation__NameAssignment_2 ) ) ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8957:1: ( ( ( rule__ForAllOrExistsOrOneOperation__NameAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8958:1: ( ( rule__ForAllOrExistsOrOneOperation__NameAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8958:1: ( ( rule__ForAllOrExistsOrOneOperation__NameAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8959:1: ( rule__ForAllOrExistsOrOneOperation__NameAssignment_2 )

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8960:1: ( rule__ForAllOrExistsOrOneOperation__NameAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8960:2: rule__ForAllOrExistsOrOneOperation__NameAssignment_2

+            {

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__NameAssignment_2_in_rule__ForAllOrExistsOrOneOperation__Group__2__Impl18663);

+            rule__ForAllOrExistsOrOneOperation__NameAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__2__Impl"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8970:1: rule__ForAllOrExistsOrOneOperation__Group__3 : rule__ForAllOrExistsOrOneOperation__Group__3__Impl rule__ForAllOrExistsOrOneOperation__Group__4 ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8974:1: ( rule__ForAllOrExistsOrOneOperation__Group__3__Impl rule__ForAllOrExistsOrOneOperation__Group__4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8975:2: rule__ForAllOrExistsOrOneOperation__Group__3__Impl rule__ForAllOrExistsOrOneOperation__Group__4

+            {

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__3__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__318693);

+            rule__ForAllOrExistsOrOneOperation__Group__3__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__4_in_rule__ForAllOrExistsOrOneOperation__Group__318696);

+            rule__ForAllOrExistsOrOneOperation__Group__4();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__3"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8982:1: rule__ForAllOrExistsOrOneOperation__Group__3__Impl : ( '(' ) ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8986:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8987:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8987:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:8988:1: '('

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getLeftParenthesisKeyword_3()); 

+            match(input,68,FOLLOW_68_in_rule__ForAllOrExistsOrOneOperation__Group__3__Impl18724); 

+             after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getLeftParenthesisKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__3__Impl"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9001:1: rule__ForAllOrExistsOrOneOperation__Group__4 : rule__ForAllOrExistsOrOneOperation__Group__4__Impl rule__ForAllOrExistsOrOneOperation__Group__5 ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9005:1: ( rule__ForAllOrExistsOrOneOperation__Group__4__Impl rule__ForAllOrExistsOrOneOperation__Group__5 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9006:2: rule__ForAllOrExistsOrOneOperation__Group__4__Impl rule__ForAllOrExistsOrOneOperation__Group__5

+            {

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__4__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__418755);

+            rule__ForAllOrExistsOrOneOperation__Group__4__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__5_in_rule__ForAllOrExistsOrOneOperation__Group__418758);

+            rule__ForAllOrExistsOrOneOperation__Group__5();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__4"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__4__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9013:1: rule__ForAllOrExistsOrOneOperation__Group__4__Impl : ( ( rule__ForAllOrExistsOrOneOperation__ExprAssignment_4 ) ) ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__4__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9017:1: ( ( ( rule__ForAllOrExistsOrOneOperation__ExprAssignment_4 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9018:1: ( ( rule__ForAllOrExistsOrOneOperation__ExprAssignment_4 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9018:1: ( ( rule__ForAllOrExistsOrOneOperation__ExprAssignment_4 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9019:1: ( rule__ForAllOrExistsOrOneOperation__ExprAssignment_4 )

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprAssignment_4()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9020:1: ( rule__ForAllOrExistsOrOneOperation__ExprAssignment_4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9020:2: rule__ForAllOrExistsOrOneOperation__ExprAssignment_4

+            {

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__ExprAssignment_4_in_rule__ForAllOrExistsOrOneOperation__Group__4__Impl18785);

+            rule__ForAllOrExistsOrOneOperation__ExprAssignment_4();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprAssignment_4()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__4__Impl"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__5"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9030:1: rule__ForAllOrExistsOrOneOperation__Group__5 : rule__ForAllOrExistsOrOneOperation__Group__5__Impl rule__ForAllOrExistsOrOneOperation__Group__6 ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__5() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9034:1: ( rule__ForAllOrExistsOrOneOperation__Group__5__Impl rule__ForAllOrExistsOrOneOperation__Group__6 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9035:2: rule__ForAllOrExistsOrOneOperation__Group__5__Impl rule__ForAllOrExistsOrOneOperation__Group__6

+            {

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__5__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__518815);

+            rule__ForAllOrExistsOrOneOperation__Group__5__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__6_in_rule__ForAllOrExistsOrOneOperation__Group__518818);

+            rule__ForAllOrExistsOrOneOperation__Group__6();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__5"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__5__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9042:1: rule__ForAllOrExistsOrOneOperation__Group__5__Impl : ( ')' ) ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__5__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9046:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9047:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9047:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9048:1: ')'

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getRightParenthesisKeyword_5()); 

+            match(input,69,FOLLOW_69_in_rule__ForAllOrExistsOrOneOperation__Group__5__Impl18846); 

+             after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getRightParenthesisKeyword_5()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__5__Impl"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9061:1: rule__ForAllOrExistsOrOneOperation__Group__6 : rule__ForAllOrExistsOrOneOperation__Group__6__Impl ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9065:1: ( rule__ForAllOrExistsOrOneOperation__Group__6__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9066:2: rule__ForAllOrExistsOrOneOperation__Group__6__Impl

+            {

+            pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__6__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__618877);

+            rule__ForAllOrExistsOrOneOperation__Group__6__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__6"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__Group__6__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9072:1: rule__ForAllOrExistsOrOneOperation__Group__6__Impl : ( ( rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6 )? ) ;

+    public final void rule__ForAllOrExistsOrOneOperation__Group__6__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9076:1: ( ( ( rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9077:1: ( ( rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9077:1: ( ( rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9078:1: ( rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6 )?

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixAssignment_6()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9079:1: ( rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6 )?

+            int alt77=2;

+            int LA77_0 = input.LA(1);

+

+            if ( (LA77_0==77||LA77_0==80) ) {

+                alt77=1;

+            }

+            switch (alt77) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9079:2: rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6

+                    {

+                    pushFollow(FOLLOW_rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6_in_rule__ForAllOrExistsOrOneOperation__Group__6__Impl18904);

+                    rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixAssignment_6()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__Group__6__Impl"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9103:1: rule__IsUniqueOperation__Group__0 : rule__IsUniqueOperation__Group__0__Impl rule__IsUniqueOperation__Group__1 ;

+    public final void rule__IsUniqueOperation__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9107:1: ( rule__IsUniqueOperation__Group__0__Impl rule__IsUniqueOperation__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9108:2: rule__IsUniqueOperation__Group__0__Impl rule__IsUniqueOperation__Group__1

+            {

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__0__Impl_in_rule__IsUniqueOperation__Group__018949);

+            rule__IsUniqueOperation__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__1_in_rule__IsUniqueOperation__Group__018952);

+            rule__IsUniqueOperation__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__0"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9115:1: rule__IsUniqueOperation__Group__0__Impl : ( '->' ) ;

+    public final void rule__IsUniqueOperation__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9119:1: ( ( '->' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9120:1: ( '->' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9120:1: ( '->' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9121:1: '->'

+            {

+             before(grammarAccess.getIsUniqueOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); 

+            match(input,80,FOLLOW_80_in_rule__IsUniqueOperation__Group__0__Impl18980); 

+             after(grammarAccess.getIsUniqueOperationAccess().getHyphenMinusGreaterThanSignKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__0__Impl"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9134:1: rule__IsUniqueOperation__Group__1 : rule__IsUniqueOperation__Group__1__Impl rule__IsUniqueOperation__Group__2 ;

+    public final void rule__IsUniqueOperation__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9138:1: ( rule__IsUniqueOperation__Group__1__Impl rule__IsUniqueOperation__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9139:2: rule__IsUniqueOperation__Group__1__Impl rule__IsUniqueOperation__Group__2

+            {

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__1__Impl_in_rule__IsUniqueOperation__Group__119011);

+            rule__IsUniqueOperation__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__2_in_rule__IsUniqueOperation__Group__119014);

+            rule__IsUniqueOperation__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__1"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9146:1: rule__IsUniqueOperation__Group__1__Impl : ( 'isUnique' ) ;

+    public final void rule__IsUniqueOperation__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9150:1: ( ( 'isUnique' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9151:1: ( 'isUnique' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9151:1: ( 'isUnique' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9152:1: 'isUnique'

+            {

+             before(grammarAccess.getIsUniqueOperationAccess().getIsUniqueKeyword_1()); 

+            match(input,82,FOLLOW_82_in_rule__IsUniqueOperation__Group__1__Impl19042); 

+             after(grammarAccess.getIsUniqueOperationAccess().getIsUniqueKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__1__Impl"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9165:1: rule__IsUniqueOperation__Group__2 : rule__IsUniqueOperation__Group__2__Impl rule__IsUniqueOperation__Group__3 ;

+    public final void rule__IsUniqueOperation__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9169:1: ( rule__IsUniqueOperation__Group__2__Impl rule__IsUniqueOperation__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9170:2: rule__IsUniqueOperation__Group__2__Impl rule__IsUniqueOperation__Group__3

+            {

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__2__Impl_in_rule__IsUniqueOperation__Group__219073);

+            rule__IsUniqueOperation__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__3_in_rule__IsUniqueOperation__Group__219076);

+            rule__IsUniqueOperation__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__2"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9177:1: rule__IsUniqueOperation__Group__2__Impl : ( ( rule__IsUniqueOperation__NameAssignment_2 ) ) ;

+    public final void rule__IsUniqueOperation__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9181:1: ( ( ( rule__IsUniqueOperation__NameAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9182:1: ( ( rule__IsUniqueOperation__NameAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9182:1: ( ( rule__IsUniqueOperation__NameAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9183:1: ( rule__IsUniqueOperation__NameAssignment_2 )

+            {

+             before(grammarAccess.getIsUniqueOperationAccess().getNameAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9184:1: ( rule__IsUniqueOperation__NameAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9184:2: rule__IsUniqueOperation__NameAssignment_2

+            {

+            pushFollow(FOLLOW_rule__IsUniqueOperation__NameAssignment_2_in_rule__IsUniqueOperation__Group__2__Impl19103);

+            rule__IsUniqueOperation__NameAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getIsUniqueOperationAccess().getNameAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__2__Impl"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9194:1: rule__IsUniqueOperation__Group__3 : rule__IsUniqueOperation__Group__3__Impl rule__IsUniqueOperation__Group__4 ;

+    public final void rule__IsUniqueOperation__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9198:1: ( rule__IsUniqueOperation__Group__3__Impl rule__IsUniqueOperation__Group__4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9199:2: rule__IsUniqueOperation__Group__3__Impl rule__IsUniqueOperation__Group__4

+            {

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__3__Impl_in_rule__IsUniqueOperation__Group__319133);

+            rule__IsUniqueOperation__Group__3__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__4_in_rule__IsUniqueOperation__Group__319136);

+            rule__IsUniqueOperation__Group__4();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__3"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9206:1: rule__IsUniqueOperation__Group__3__Impl : ( '(' ) ;

+    public final void rule__IsUniqueOperation__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9210:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9211:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9211:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9212:1: '('

+            {

+             before(grammarAccess.getIsUniqueOperationAccess().getLeftParenthesisKeyword_3()); 

+            match(input,68,FOLLOW_68_in_rule__IsUniqueOperation__Group__3__Impl19164); 

+             after(grammarAccess.getIsUniqueOperationAccess().getLeftParenthesisKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__3__Impl"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9225:1: rule__IsUniqueOperation__Group__4 : rule__IsUniqueOperation__Group__4__Impl rule__IsUniqueOperation__Group__5 ;

+    public final void rule__IsUniqueOperation__Group__4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9229:1: ( rule__IsUniqueOperation__Group__4__Impl rule__IsUniqueOperation__Group__5 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9230:2: rule__IsUniqueOperation__Group__4__Impl rule__IsUniqueOperation__Group__5

+            {

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__4__Impl_in_rule__IsUniqueOperation__Group__419195);

+            rule__IsUniqueOperation__Group__4__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__5_in_rule__IsUniqueOperation__Group__419198);

+            rule__IsUniqueOperation__Group__5();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__4"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__4__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9237:1: rule__IsUniqueOperation__Group__4__Impl : ( ( rule__IsUniqueOperation__ExprAssignment_4 ) ) ;

+    public final void rule__IsUniqueOperation__Group__4__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9241:1: ( ( ( rule__IsUniqueOperation__ExprAssignment_4 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9242:1: ( ( rule__IsUniqueOperation__ExprAssignment_4 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9242:1: ( ( rule__IsUniqueOperation__ExprAssignment_4 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9243:1: ( rule__IsUniqueOperation__ExprAssignment_4 )

+            {

+             before(grammarAccess.getIsUniqueOperationAccess().getExprAssignment_4()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9244:1: ( rule__IsUniqueOperation__ExprAssignment_4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9244:2: rule__IsUniqueOperation__ExprAssignment_4

+            {

+            pushFollow(FOLLOW_rule__IsUniqueOperation__ExprAssignment_4_in_rule__IsUniqueOperation__Group__4__Impl19225);

+            rule__IsUniqueOperation__ExprAssignment_4();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getIsUniqueOperationAccess().getExprAssignment_4()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__4__Impl"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__5"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9254:1: rule__IsUniqueOperation__Group__5 : rule__IsUniqueOperation__Group__5__Impl rule__IsUniqueOperation__Group__6 ;

+    public final void rule__IsUniqueOperation__Group__5() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9258:1: ( rule__IsUniqueOperation__Group__5__Impl rule__IsUniqueOperation__Group__6 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9259:2: rule__IsUniqueOperation__Group__5__Impl rule__IsUniqueOperation__Group__6

+            {

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__5__Impl_in_rule__IsUniqueOperation__Group__519255);

+            rule__IsUniqueOperation__Group__5__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__6_in_rule__IsUniqueOperation__Group__519258);

+            rule__IsUniqueOperation__Group__6();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__5"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__5__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9266:1: rule__IsUniqueOperation__Group__5__Impl : ( ')' ) ;

+    public final void rule__IsUniqueOperation__Group__5__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9270:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9271:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9271:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9272:1: ')'

+            {

+             before(grammarAccess.getIsUniqueOperationAccess().getRightParenthesisKeyword_5()); 

+            match(input,69,FOLLOW_69_in_rule__IsUniqueOperation__Group__5__Impl19286); 

+             after(grammarAccess.getIsUniqueOperationAccess().getRightParenthesisKeyword_5()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__5__Impl"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9285:1: rule__IsUniqueOperation__Group__6 : rule__IsUniqueOperation__Group__6__Impl ;

+    public final void rule__IsUniqueOperation__Group__6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9289:1: ( rule__IsUniqueOperation__Group__6__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9290:2: rule__IsUniqueOperation__Group__6__Impl

+            {

+            pushFollow(FOLLOW_rule__IsUniqueOperation__Group__6__Impl_in_rule__IsUniqueOperation__Group__619317);

+            rule__IsUniqueOperation__Group__6__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__6"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__Group__6__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9296:1: rule__IsUniqueOperation__Group__6__Impl : ( ( rule__IsUniqueOperation__SuffixAssignment_6 )? ) ;

+    public final void rule__IsUniqueOperation__Group__6__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9300:1: ( ( ( rule__IsUniqueOperation__SuffixAssignment_6 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9301:1: ( ( rule__IsUniqueOperation__SuffixAssignment_6 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9301:1: ( ( rule__IsUniqueOperation__SuffixAssignment_6 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9302:1: ( rule__IsUniqueOperation__SuffixAssignment_6 )?

+            {

+             before(grammarAccess.getIsUniqueOperationAccess().getSuffixAssignment_6()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9303:1: ( rule__IsUniqueOperation__SuffixAssignment_6 )?

+            int alt78=2;

+            int LA78_0 = input.LA(1);

+

+            if ( (LA78_0==77||LA78_0==80) ) {

+                alt78=1;

+            }

+            switch (alt78) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9303:2: rule__IsUniqueOperation__SuffixAssignment_6

+                    {

+                    pushFollow(FOLLOW_rule__IsUniqueOperation__SuffixAssignment_6_in_rule__IsUniqueOperation__Group__6__Impl19344);

+                    rule__IsUniqueOperation__SuffixAssignment_6();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getIsUniqueOperationAccess().getSuffixAssignment_6()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__Group__6__Impl"

+

+

+    // $ANTLR start "rule__ParenthesizedExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9327:1: rule__ParenthesizedExpression__Group__0 : rule__ParenthesizedExpression__Group__0__Impl rule__ParenthesizedExpression__Group__1 ;

+    public final void rule__ParenthesizedExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9331:1: ( rule__ParenthesizedExpression__Group__0__Impl rule__ParenthesizedExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9332:2: rule__ParenthesizedExpression__Group__0__Impl rule__ParenthesizedExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__ParenthesizedExpression__Group__0__Impl_in_rule__ParenthesizedExpression__Group__019389);

+            rule__ParenthesizedExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ParenthesizedExpression__Group__1_in_rule__ParenthesizedExpression__Group__019392);

+            rule__ParenthesizedExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ParenthesizedExpression__Group__0"

+

+

+    // $ANTLR start "rule__ParenthesizedExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9339:1: rule__ParenthesizedExpression__Group__0__Impl : ( '(' ) ;

+    public final void rule__ParenthesizedExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9343:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9344:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9344:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9345:1: '('

+            {

+             before(grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); 

+            match(input,68,FOLLOW_68_in_rule__ParenthesizedExpression__Group__0__Impl19420); 

+             after(grammarAccess.getParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ParenthesizedExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ParenthesizedExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9358:1: rule__ParenthesizedExpression__Group__1 : rule__ParenthesizedExpression__Group__1__Impl rule__ParenthesizedExpression__Group__2 ;

+    public final void rule__ParenthesizedExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9362:1: ( rule__ParenthesizedExpression__Group__1__Impl rule__ParenthesizedExpression__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9363:2: rule__ParenthesizedExpression__Group__1__Impl rule__ParenthesizedExpression__Group__2

+            {

+            pushFollow(FOLLOW_rule__ParenthesizedExpression__Group__1__Impl_in_rule__ParenthesizedExpression__Group__119451);

+            rule__ParenthesizedExpression__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ParenthesizedExpression__Group__2_in_rule__ParenthesizedExpression__Group__119454);

+            rule__ParenthesizedExpression__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ParenthesizedExpression__Group__1"

+

+

+    // $ANTLR start "rule__ParenthesizedExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9370:1: rule__ParenthesizedExpression__Group__1__Impl : ( ( rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1 ) ) ;

+    public final void rule__ParenthesizedExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9374:1: ( ( ( rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9375:1: ( ( rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9375:1: ( ( rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9376:1: ( rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1 )

+            {

+             before(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9377:1: ( rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9377:2: rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1

+            {

+            pushFollow(FOLLOW_rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1_in_rule__ParenthesizedExpression__Group__1__Impl19481);

+            rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ParenthesizedExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ParenthesizedExpression__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9387:1: rule__ParenthesizedExpression__Group__2 : rule__ParenthesizedExpression__Group__2__Impl rule__ParenthesizedExpression__Group__3 ;

+    public final void rule__ParenthesizedExpression__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9391:1: ( rule__ParenthesizedExpression__Group__2__Impl rule__ParenthesizedExpression__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9392:2: rule__ParenthesizedExpression__Group__2__Impl rule__ParenthesizedExpression__Group__3

+            {

+            pushFollow(FOLLOW_rule__ParenthesizedExpression__Group__2__Impl_in_rule__ParenthesizedExpression__Group__219511);

+            rule__ParenthesizedExpression__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ParenthesizedExpression__Group__3_in_rule__ParenthesizedExpression__Group__219514);

+            rule__ParenthesizedExpression__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ParenthesizedExpression__Group__2"

+

+

+    // $ANTLR start "rule__ParenthesizedExpression__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9399:1: rule__ParenthesizedExpression__Group__2__Impl : ( ')' ) ;

+    public final void rule__ParenthesizedExpression__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9403:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9404:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9404:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9405:1: ')'

+            {

+             before(grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); 

+            match(input,69,FOLLOW_69_in_rule__ParenthesizedExpression__Group__2__Impl19542); 

+             after(grammarAccess.getParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ParenthesizedExpression__Group__2__Impl"

+

+

+    // $ANTLR start "rule__ParenthesizedExpression__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9418:1: rule__ParenthesizedExpression__Group__3 : rule__ParenthesizedExpression__Group__3__Impl ;

+    public final void rule__ParenthesizedExpression__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9422:1: ( rule__ParenthesizedExpression__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9423:2: rule__ParenthesizedExpression__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__ParenthesizedExpression__Group__3__Impl_in_rule__ParenthesizedExpression__Group__319573);

+            rule__ParenthesizedExpression__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ParenthesizedExpression__Group__3"

+

+

+    // $ANTLR start "rule__ParenthesizedExpression__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9429:1: rule__ParenthesizedExpression__Group__3__Impl : ( ( rule__ParenthesizedExpression__Alternatives_3 )? ) ;

+    public final void rule__ParenthesizedExpression__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9433:1: ( ( ( rule__ParenthesizedExpression__Alternatives_3 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9434:1: ( ( rule__ParenthesizedExpression__Alternatives_3 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9434:1: ( ( rule__ParenthesizedExpression__Alternatives_3 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9435:1: ( rule__ParenthesizedExpression__Alternatives_3 )?

+            {

+             before(grammarAccess.getParenthesizedExpressionAccess().getAlternatives_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9436:1: ( rule__ParenthesizedExpression__Alternatives_3 )?

+            int alt79=2;

+            int LA79_0 = input.LA(1);

+

+            if ( (LA79_0==RULE_ID||(LA79_0>=12 && LA79_0<=13)||LA79_0==68||LA79_0==77||LA79_0==80||(LA79_0>=84 && LA79_0<=86)) ) {

+                alt79=1;

+            }

+            switch (alt79) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9436:2: rule__ParenthesizedExpression__Alternatives_3

+                    {

+                    pushFollow(FOLLOW_rule__ParenthesizedExpression__Alternatives_3_in_rule__ParenthesizedExpression__Group__3__Impl19600);

+                    rule__ParenthesizedExpression__Alternatives_3();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getParenthesizedExpressionAccess().getAlternatives_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ParenthesizedExpression__Group__3__Impl"

+

+

+    // $ANTLR start "rule__NullExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9454:1: rule__NullExpression__Group__0 : rule__NullExpression__Group__0__Impl rule__NullExpression__Group__1 ;

+    public final void rule__NullExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9458:1: ( rule__NullExpression__Group__0__Impl rule__NullExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9459:2: rule__NullExpression__Group__0__Impl rule__NullExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__NullExpression__Group__0__Impl_in_rule__NullExpression__Group__019639);

+            rule__NullExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__NullExpression__Group__1_in_rule__NullExpression__Group__019642);

+            rule__NullExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NullExpression__Group__0"

+

+

+    // $ANTLR start "rule__NullExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9466:1: rule__NullExpression__Group__0__Impl : ( () ) ;

+    public final void rule__NullExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9470:1: ( ( () ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9471:1: ( () )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9471:1: ( () )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9472:1: ()

+            {

+             before(grammarAccess.getNullExpressionAccess().getNullExpressionAction_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9473:1: ()

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9475:1: 

+            {

+            }

+

+             after(grammarAccess.getNullExpressionAccess().getNullExpressionAction_0()); 

+

+            }

+

+

+            }

+

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NullExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__NullExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9485:1: rule__NullExpression__Group__1 : rule__NullExpression__Group__1__Impl ;

+    public final void rule__NullExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9489:1: ( rule__NullExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9490:2: rule__NullExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__NullExpression__Group__1__Impl_in_rule__NullExpression__Group__119700);

+            rule__NullExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NullExpression__Group__1"

+

+

+    // $ANTLR start "rule__NullExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9496:1: rule__NullExpression__Group__1__Impl : ( 'null' ) ;

+    public final void rule__NullExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9500:1: ( ( 'null' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9501:1: ( 'null' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9501:1: ( 'null' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9502:1: 'null'

+            {

+             before(grammarAccess.getNullExpressionAccess().getNullKeyword_1()); 

+            match(input,83,FOLLOW_83_in_rule__NullExpression__Group__1__Impl19728); 

+             after(grammarAccess.getNullExpressionAccess().getNullKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NullExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ThisExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9519:1: rule__ThisExpression__Group__0 : rule__ThisExpression__Group__0__Impl rule__ThisExpression__Group__1 ;

+    public final void rule__ThisExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9523:1: ( rule__ThisExpression__Group__0__Impl rule__ThisExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9524:2: rule__ThisExpression__Group__0__Impl rule__ThisExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__ThisExpression__Group__0__Impl_in_rule__ThisExpression__Group__019763);

+            rule__ThisExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ThisExpression__Group__1_in_rule__ThisExpression__Group__019766);

+            rule__ThisExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisExpression__Group__0"

+

+

+    // $ANTLR start "rule__ThisExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9531:1: rule__ThisExpression__Group__0__Impl : ( () ) ;

+    public final void rule__ThisExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9535:1: ( ( () ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9536:1: ( () )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9536:1: ( () )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9537:1: ()

+            {

+             before(grammarAccess.getThisExpressionAccess().getThisExpressionAction_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9538:1: ()

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9540:1: 

+            {

+            }

+

+             after(grammarAccess.getThisExpressionAccess().getThisExpressionAction_0()); 

+

+            }

+

+

+            }

+

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ThisExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9550:1: rule__ThisExpression__Group__1 : rule__ThisExpression__Group__1__Impl rule__ThisExpression__Group__2 ;

+    public final void rule__ThisExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9554:1: ( rule__ThisExpression__Group__1__Impl rule__ThisExpression__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9555:2: rule__ThisExpression__Group__1__Impl rule__ThisExpression__Group__2

+            {

+            pushFollow(FOLLOW_rule__ThisExpression__Group__1__Impl_in_rule__ThisExpression__Group__119824);

+            rule__ThisExpression__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ThisExpression__Group__2_in_rule__ThisExpression__Group__119827);

+            rule__ThisExpression__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisExpression__Group__1"

+

+

+    // $ANTLR start "rule__ThisExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9562:1: rule__ThisExpression__Group__1__Impl : ( 'this' ) ;

+    public final void rule__ThisExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9566:1: ( ( 'this' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9567:1: ( 'this' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9567:1: ( 'this' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9568:1: 'this'

+            {

+             before(grammarAccess.getThisExpressionAccess().getThisKeyword_1()); 

+            match(input,84,FOLLOW_84_in_rule__ThisExpression__Group__1__Impl19855); 

+             after(grammarAccess.getThisExpressionAccess().getThisKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ThisExpression__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9581:1: rule__ThisExpression__Group__2 : rule__ThisExpression__Group__2__Impl ;

+    public final void rule__ThisExpression__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9585:1: ( rule__ThisExpression__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9586:2: rule__ThisExpression__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__ThisExpression__Group__2__Impl_in_rule__ThisExpression__Group__219886);

+            rule__ThisExpression__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisExpression__Group__2"

+

+

+    // $ANTLR start "rule__ThisExpression__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9592:1: rule__ThisExpression__Group__2__Impl : ( ( rule__ThisExpression__SuffixAssignment_2 )? ) ;

+    public final void rule__ThisExpression__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9596:1: ( ( ( rule__ThisExpression__SuffixAssignment_2 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9597:1: ( ( rule__ThisExpression__SuffixAssignment_2 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9597:1: ( ( rule__ThisExpression__SuffixAssignment_2 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9598:1: ( rule__ThisExpression__SuffixAssignment_2 )?

+            {

+             before(grammarAccess.getThisExpressionAccess().getSuffixAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9599:1: ( rule__ThisExpression__SuffixAssignment_2 )?

+            int alt80=2;

+            int LA80_0 = input.LA(1);

+

+            if ( (LA80_0==77||LA80_0==80) ) {

+                alt80=1;

+            }

+            switch (alt80) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9599:2: rule__ThisExpression__SuffixAssignment_2

+                    {

+                    pushFollow(FOLLOW_rule__ThisExpression__SuffixAssignment_2_in_rule__ThisExpression__Group__2__Impl19913);

+                    rule__ThisExpression__SuffixAssignment_2();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getThisExpressionAccess().getSuffixAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisExpression__Group__2__Impl"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9615:1: rule__SuperInvocationExpression__Group__0 : rule__SuperInvocationExpression__Group__0__Impl rule__SuperInvocationExpression__Group__1 ;

+    public final void rule__SuperInvocationExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9619:1: ( rule__SuperInvocationExpression__Group__0__Impl rule__SuperInvocationExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9620:2: rule__SuperInvocationExpression__Group__0__Impl rule__SuperInvocationExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__SuperInvocationExpression__Group__0__Impl_in_rule__SuperInvocationExpression__Group__019950);

+            rule__SuperInvocationExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SuperInvocationExpression__Group__1_in_rule__SuperInvocationExpression__Group__019953);

+            rule__SuperInvocationExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__Group__0"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9627:1: rule__SuperInvocationExpression__Group__0__Impl : ( 'super' ) ;

+    public final void rule__SuperInvocationExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9631:1: ( ( 'super' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9632:1: ( 'super' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9632:1: ( 'super' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9633:1: 'super'

+            {

+             before(grammarAccess.getSuperInvocationExpressionAccess().getSuperKeyword_0()); 

+            match(input,85,FOLLOW_85_in_rule__SuperInvocationExpression__Group__0__Impl19981); 

+             after(grammarAccess.getSuperInvocationExpressionAccess().getSuperKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9646:1: rule__SuperInvocationExpression__Group__1 : rule__SuperInvocationExpression__Group__1__Impl ;

+    public final void rule__SuperInvocationExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9650:1: ( rule__SuperInvocationExpression__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9651:2: rule__SuperInvocationExpression__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__SuperInvocationExpression__Group__1__Impl_in_rule__SuperInvocationExpression__Group__120012);

+            rule__SuperInvocationExpression__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__Group__1"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9657:1: rule__SuperInvocationExpression__Group__1__Impl : ( ( rule__SuperInvocationExpression__Alternatives_1 ) ) ;

+    public final void rule__SuperInvocationExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9661:1: ( ( ( rule__SuperInvocationExpression__Alternatives_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9662:1: ( ( rule__SuperInvocationExpression__Alternatives_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9662:1: ( ( rule__SuperInvocationExpression__Alternatives_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9663:1: ( rule__SuperInvocationExpression__Alternatives_1 )

+            {

+             before(grammarAccess.getSuperInvocationExpressionAccess().getAlternatives_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9664:1: ( rule__SuperInvocationExpression__Alternatives_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9664:2: rule__SuperInvocationExpression__Alternatives_1

+            {

+            pushFollow(FOLLOW_rule__SuperInvocationExpression__Alternatives_1_in_rule__SuperInvocationExpression__Group__1__Impl20039);

+            rule__SuperInvocationExpression__Alternatives_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSuperInvocationExpressionAccess().getAlternatives_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__Group_1_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9678:1: rule__SuperInvocationExpression__Group_1_1__0 : rule__SuperInvocationExpression__Group_1_1__0__Impl rule__SuperInvocationExpression__Group_1_1__1 ;

+    public final void rule__SuperInvocationExpression__Group_1_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9682:1: ( rule__SuperInvocationExpression__Group_1_1__0__Impl rule__SuperInvocationExpression__Group_1_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9683:2: rule__SuperInvocationExpression__Group_1_1__0__Impl rule__SuperInvocationExpression__Group_1_1__1

+            {

+            pushFollow(FOLLOW_rule__SuperInvocationExpression__Group_1_1__0__Impl_in_rule__SuperInvocationExpression__Group_1_1__020073);

+            rule__SuperInvocationExpression__Group_1_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SuperInvocationExpression__Group_1_1__1_in_rule__SuperInvocationExpression__Group_1_1__020076);

+            rule__SuperInvocationExpression__Group_1_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__Group_1_1__0"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__Group_1_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9690:1: rule__SuperInvocationExpression__Group_1_1__0__Impl : ( '.' ) ;

+    public final void rule__SuperInvocationExpression__Group_1_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9694:1: ( ( '.' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9695:1: ( '.' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9695:1: ( '.' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9696:1: '.'

+            {

+             before(grammarAccess.getSuperInvocationExpressionAccess().getFullStopKeyword_1_1_0()); 

+            match(input,77,FOLLOW_77_in_rule__SuperInvocationExpression__Group_1_1__0__Impl20104); 

+             after(grammarAccess.getSuperInvocationExpressionAccess().getFullStopKeyword_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__Group_1_1__0__Impl"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__Group_1_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9709:1: rule__SuperInvocationExpression__Group_1_1__1 : rule__SuperInvocationExpression__Group_1_1__1__Impl rule__SuperInvocationExpression__Group_1_1__2 ;

+    public final void rule__SuperInvocationExpression__Group_1_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9713:1: ( rule__SuperInvocationExpression__Group_1_1__1__Impl rule__SuperInvocationExpression__Group_1_1__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9714:2: rule__SuperInvocationExpression__Group_1_1__1__Impl rule__SuperInvocationExpression__Group_1_1__2

+            {

+            pushFollow(FOLLOW_rule__SuperInvocationExpression__Group_1_1__1__Impl_in_rule__SuperInvocationExpression__Group_1_1__120135);

+            rule__SuperInvocationExpression__Group_1_1__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SuperInvocationExpression__Group_1_1__2_in_rule__SuperInvocationExpression__Group_1_1__120138);

+            rule__SuperInvocationExpression__Group_1_1__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__Group_1_1__1"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__Group_1_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9721:1: rule__SuperInvocationExpression__Group_1_1__1__Impl : ( ( rule__SuperInvocationExpression__OperationNameAssignment_1_1_1 ) ) ;

+    public final void rule__SuperInvocationExpression__Group_1_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9725:1: ( ( ( rule__SuperInvocationExpression__OperationNameAssignment_1_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9726:1: ( ( rule__SuperInvocationExpression__OperationNameAssignment_1_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9726:1: ( ( rule__SuperInvocationExpression__OperationNameAssignment_1_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9727:1: ( rule__SuperInvocationExpression__OperationNameAssignment_1_1_1 )

+            {

+             before(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameAssignment_1_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9728:1: ( rule__SuperInvocationExpression__OperationNameAssignment_1_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9728:2: rule__SuperInvocationExpression__OperationNameAssignment_1_1_1

+            {

+            pushFollow(FOLLOW_rule__SuperInvocationExpression__OperationNameAssignment_1_1_1_in_rule__SuperInvocationExpression__Group_1_1__1__Impl20165);

+            rule__SuperInvocationExpression__OperationNameAssignment_1_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameAssignment_1_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__Group_1_1__1__Impl"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__Group_1_1__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9738:1: rule__SuperInvocationExpression__Group_1_1__2 : rule__SuperInvocationExpression__Group_1_1__2__Impl ;

+    public final void rule__SuperInvocationExpression__Group_1_1__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9742:1: ( rule__SuperInvocationExpression__Group_1_1__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9743:2: rule__SuperInvocationExpression__Group_1_1__2__Impl

+            {

+            pushFollow(FOLLOW_rule__SuperInvocationExpression__Group_1_1__2__Impl_in_rule__SuperInvocationExpression__Group_1_1__220195);

+            rule__SuperInvocationExpression__Group_1_1__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__Group_1_1__2"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__Group_1_1__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9749:1: rule__SuperInvocationExpression__Group_1_1__2__Impl : ( ( rule__SuperInvocationExpression__TupleAssignment_1_1_2 ) ) ;

+    public final void rule__SuperInvocationExpression__Group_1_1__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9753:1: ( ( ( rule__SuperInvocationExpression__TupleAssignment_1_1_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9754:1: ( ( rule__SuperInvocationExpression__TupleAssignment_1_1_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9754:1: ( ( rule__SuperInvocationExpression__TupleAssignment_1_1_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9755:1: ( rule__SuperInvocationExpression__TupleAssignment_1_1_2 )

+            {

+             before(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_1_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9756:1: ( rule__SuperInvocationExpression__TupleAssignment_1_1_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9756:2: rule__SuperInvocationExpression__TupleAssignment_1_1_2

+            {

+            pushFollow(FOLLOW_rule__SuperInvocationExpression__TupleAssignment_1_1_2_in_rule__SuperInvocationExpression__Group_1_1__2__Impl20222);

+            rule__SuperInvocationExpression__TupleAssignment_1_1_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSuperInvocationExpressionAccess().getTupleAssignment_1_1_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__Group_1_1__2__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9772:1: rule__InstanceCreationExpression__Group__0 : rule__InstanceCreationExpression__Group__0__Impl rule__InstanceCreationExpression__Group__1 ;

+    public final void rule__InstanceCreationExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9776:1: ( rule__InstanceCreationExpression__Group__0__Impl rule__InstanceCreationExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9777:2: rule__InstanceCreationExpression__Group__0__Impl rule__InstanceCreationExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationExpression__Group__0__Impl_in_rule__InstanceCreationExpression__Group__020258);

+            rule__InstanceCreationExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InstanceCreationExpression__Group__1_in_rule__InstanceCreationExpression__Group__020261);

+            rule__InstanceCreationExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationExpression__Group__0"

+

+

+    // $ANTLR start "rule__InstanceCreationExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9784:1: rule__InstanceCreationExpression__Group__0__Impl : ( 'new' ) ;

+    public final void rule__InstanceCreationExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9788:1: ( ( 'new' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9789:1: ( 'new' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9789:1: ( 'new' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9790:1: 'new'

+            {

+             before(grammarAccess.getInstanceCreationExpressionAccess().getNewKeyword_0()); 

+            match(input,86,FOLLOW_86_in_rule__InstanceCreationExpression__Group__0__Impl20289); 

+             after(grammarAccess.getInstanceCreationExpressionAccess().getNewKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9803:1: rule__InstanceCreationExpression__Group__1 : rule__InstanceCreationExpression__Group__1__Impl rule__InstanceCreationExpression__Group__2 ;

+    public final void rule__InstanceCreationExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9807:1: ( rule__InstanceCreationExpression__Group__1__Impl rule__InstanceCreationExpression__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9808:2: rule__InstanceCreationExpression__Group__1__Impl rule__InstanceCreationExpression__Group__2

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationExpression__Group__1__Impl_in_rule__InstanceCreationExpression__Group__120320);

+            rule__InstanceCreationExpression__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InstanceCreationExpression__Group__2_in_rule__InstanceCreationExpression__Group__120323);

+            rule__InstanceCreationExpression__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationExpression__Group__1"

+

+

+    // $ANTLR start "rule__InstanceCreationExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9815:1: rule__InstanceCreationExpression__Group__1__Impl : ( ( rule__InstanceCreationExpression__ConstructorAssignment_1 ) ) ;

+    public final void rule__InstanceCreationExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9819:1: ( ( ( rule__InstanceCreationExpression__ConstructorAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9820:1: ( ( rule__InstanceCreationExpression__ConstructorAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9820:1: ( ( rule__InstanceCreationExpression__ConstructorAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9821:1: ( rule__InstanceCreationExpression__ConstructorAssignment_1 )

+            {

+             before(grammarAccess.getInstanceCreationExpressionAccess().getConstructorAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9822:1: ( rule__InstanceCreationExpression__ConstructorAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9822:2: rule__InstanceCreationExpression__ConstructorAssignment_1

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationExpression__ConstructorAssignment_1_in_rule__InstanceCreationExpression__Group__1__Impl20350);

+            rule__InstanceCreationExpression__ConstructorAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInstanceCreationExpressionAccess().getConstructorAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationExpression__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9832:1: rule__InstanceCreationExpression__Group__2 : rule__InstanceCreationExpression__Group__2__Impl rule__InstanceCreationExpression__Group__3 ;

+    public final void rule__InstanceCreationExpression__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9836:1: ( rule__InstanceCreationExpression__Group__2__Impl rule__InstanceCreationExpression__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9837:2: rule__InstanceCreationExpression__Group__2__Impl rule__InstanceCreationExpression__Group__3

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationExpression__Group__2__Impl_in_rule__InstanceCreationExpression__Group__220380);

+            rule__InstanceCreationExpression__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InstanceCreationExpression__Group__3_in_rule__InstanceCreationExpression__Group__220383);

+            rule__InstanceCreationExpression__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationExpression__Group__2"

+

+

+    // $ANTLR start "rule__InstanceCreationExpression__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9844:1: rule__InstanceCreationExpression__Group__2__Impl : ( ( rule__InstanceCreationExpression__TupleAssignment_2 ) ) ;

+    public final void rule__InstanceCreationExpression__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9848:1: ( ( ( rule__InstanceCreationExpression__TupleAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9849:1: ( ( rule__InstanceCreationExpression__TupleAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9849:1: ( ( rule__InstanceCreationExpression__TupleAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9850:1: ( rule__InstanceCreationExpression__TupleAssignment_2 )

+            {

+             before(grammarAccess.getInstanceCreationExpressionAccess().getTupleAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9851:1: ( rule__InstanceCreationExpression__TupleAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9851:2: rule__InstanceCreationExpression__TupleAssignment_2

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationExpression__TupleAssignment_2_in_rule__InstanceCreationExpression__Group__2__Impl20410);

+            rule__InstanceCreationExpression__TupleAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInstanceCreationExpressionAccess().getTupleAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationExpression__Group__2__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationExpression__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9861:1: rule__InstanceCreationExpression__Group__3 : rule__InstanceCreationExpression__Group__3__Impl ;

+    public final void rule__InstanceCreationExpression__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9865:1: ( rule__InstanceCreationExpression__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9866:2: rule__InstanceCreationExpression__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationExpression__Group__3__Impl_in_rule__InstanceCreationExpression__Group__320440);

+            rule__InstanceCreationExpression__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationExpression__Group__3"

+

+

+    // $ANTLR start "rule__InstanceCreationExpression__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9872:1: rule__InstanceCreationExpression__Group__3__Impl : ( ( rule__InstanceCreationExpression__SuffixAssignment_3 )? ) ;

+    public final void rule__InstanceCreationExpression__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9876:1: ( ( ( rule__InstanceCreationExpression__SuffixAssignment_3 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9877:1: ( ( rule__InstanceCreationExpression__SuffixAssignment_3 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9877:1: ( ( rule__InstanceCreationExpression__SuffixAssignment_3 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9878:1: ( rule__InstanceCreationExpression__SuffixAssignment_3 )?

+            {

+             before(grammarAccess.getInstanceCreationExpressionAccess().getSuffixAssignment_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9879:1: ( rule__InstanceCreationExpression__SuffixAssignment_3 )?

+            int alt81=2;

+            int LA81_0 = input.LA(1);

+

+            if ( (LA81_0==77||LA81_0==80) ) {

+                alt81=1;

+            }

+            switch (alt81) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9879:2: rule__InstanceCreationExpression__SuffixAssignment_3

+                    {

+                    pushFollow(FOLLOW_rule__InstanceCreationExpression__SuffixAssignment_3_in_rule__InstanceCreationExpression__Group__3__Impl20467);

+                    rule__InstanceCreationExpression__SuffixAssignment_3();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getInstanceCreationExpressionAccess().getSuffixAssignment_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationExpression__Group__3__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9897:1: rule__InstanceCreationTuple__Group__0 : rule__InstanceCreationTuple__Group__0__Impl rule__InstanceCreationTuple__Group__1 ;

+    public final void rule__InstanceCreationTuple__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9901:1: ( rule__InstanceCreationTuple__Group__0__Impl rule__InstanceCreationTuple__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9902:2: rule__InstanceCreationTuple__Group__0__Impl rule__InstanceCreationTuple__Group__1

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group__0__Impl_in_rule__InstanceCreationTuple__Group__020506);

+            rule__InstanceCreationTuple__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group__1_in_rule__InstanceCreationTuple__Group__020509);

+            rule__InstanceCreationTuple__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group__0"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9909:1: rule__InstanceCreationTuple__Group__0__Impl : ( () ) ;

+    public final void rule__InstanceCreationTuple__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9913:1: ( ( () ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9914:1: ( () )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9914:1: ( () )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9915:1: ()

+            {

+             before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleAction_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9916:1: ()

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9918:1: 

+            {

+            }

+

+             after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleAction_0()); 

+

+            }

+

+

+            }

+

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group__0__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9928:1: rule__InstanceCreationTuple__Group__1 : rule__InstanceCreationTuple__Group__1__Impl rule__InstanceCreationTuple__Group__2 ;

+    public final void rule__InstanceCreationTuple__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9932:1: ( rule__InstanceCreationTuple__Group__1__Impl rule__InstanceCreationTuple__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9933:2: rule__InstanceCreationTuple__Group__1__Impl rule__InstanceCreationTuple__Group__2

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group__1__Impl_in_rule__InstanceCreationTuple__Group__120567);

+            rule__InstanceCreationTuple__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group__2_in_rule__InstanceCreationTuple__Group__120570);

+            rule__InstanceCreationTuple__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group__1"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9940:1: rule__InstanceCreationTuple__Group__1__Impl : ( '(' ) ;

+    public final void rule__InstanceCreationTuple__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9944:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9945:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9945:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9946:1: '('

+            {

+             before(grammarAccess.getInstanceCreationTupleAccess().getLeftParenthesisKeyword_1()); 

+            match(input,68,FOLLOW_68_in_rule__InstanceCreationTuple__Group__1__Impl20598); 

+             after(grammarAccess.getInstanceCreationTupleAccess().getLeftParenthesisKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group__1__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9959:1: rule__InstanceCreationTuple__Group__2 : rule__InstanceCreationTuple__Group__2__Impl rule__InstanceCreationTuple__Group__3 ;

+    public final void rule__InstanceCreationTuple__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9963:1: ( rule__InstanceCreationTuple__Group__2__Impl rule__InstanceCreationTuple__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9964:2: rule__InstanceCreationTuple__Group__2__Impl rule__InstanceCreationTuple__Group__3

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group__2__Impl_in_rule__InstanceCreationTuple__Group__220629);

+            rule__InstanceCreationTuple__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group__3_in_rule__InstanceCreationTuple__Group__220632);

+            rule__InstanceCreationTuple__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group__2"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9971:1: rule__InstanceCreationTuple__Group__2__Impl : ( ( rule__InstanceCreationTuple__Group_2__0 )? ) ;

+    public final void rule__InstanceCreationTuple__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9975:1: ( ( ( rule__InstanceCreationTuple__Group_2__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9976:1: ( ( rule__InstanceCreationTuple__Group_2__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9976:1: ( ( rule__InstanceCreationTuple__Group_2__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9977:1: ( rule__InstanceCreationTuple__Group_2__0 )?

+            {

+             before(grammarAccess.getInstanceCreationTupleAccess().getGroup_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9978:1: ( rule__InstanceCreationTuple__Group_2__0 )?

+            int alt82=2;

+            int LA82_0 = input.LA(1);

+

+            if ( (LA82_0==RULE_ID) ) {

+                alt82=1;

+            }

+            switch (alt82) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9978:2: rule__InstanceCreationTuple__Group_2__0

+                    {

+                    pushFollow(FOLLOW_rule__InstanceCreationTuple__Group_2__0_in_rule__InstanceCreationTuple__Group__2__Impl20659);

+                    rule__InstanceCreationTuple__Group_2__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getInstanceCreationTupleAccess().getGroup_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group__2__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9988:1: rule__InstanceCreationTuple__Group__3 : rule__InstanceCreationTuple__Group__3__Impl ;

+    public final void rule__InstanceCreationTuple__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9992:1: ( rule__InstanceCreationTuple__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9993:2: rule__InstanceCreationTuple__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group__3__Impl_in_rule__InstanceCreationTuple__Group__320690);

+            rule__InstanceCreationTuple__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group__3"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:9999:1: rule__InstanceCreationTuple__Group__3__Impl : ( ')' ) ;

+    public final void rule__InstanceCreationTuple__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10003:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10004:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10004:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10005:1: ')'

+            {

+             before(grammarAccess.getInstanceCreationTupleAccess().getRightParenthesisKeyword_3()); 

+            match(input,69,FOLLOW_69_in_rule__InstanceCreationTuple__Group__3__Impl20718); 

+             after(grammarAccess.getInstanceCreationTupleAccess().getRightParenthesisKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group__3__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group_2__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10026:1: rule__InstanceCreationTuple__Group_2__0 : rule__InstanceCreationTuple__Group_2__0__Impl rule__InstanceCreationTuple__Group_2__1 ;

+    public final void rule__InstanceCreationTuple__Group_2__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10030:1: ( rule__InstanceCreationTuple__Group_2__0__Impl rule__InstanceCreationTuple__Group_2__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10031:2: rule__InstanceCreationTuple__Group_2__0__Impl rule__InstanceCreationTuple__Group_2__1

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group_2__0__Impl_in_rule__InstanceCreationTuple__Group_2__020757);

+            rule__InstanceCreationTuple__Group_2__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group_2__1_in_rule__InstanceCreationTuple__Group_2__020760);

+            rule__InstanceCreationTuple__Group_2__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group_2__0"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group_2__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10038:1: rule__InstanceCreationTuple__Group_2__0__Impl : ( ( rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0 ) ) ;

+    public final void rule__InstanceCreationTuple__Group_2__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10042:1: ( ( ( rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10043:1: ( ( rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10043:1: ( ( rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10044:1: ( rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0 )

+            {

+             before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10045:1: ( rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10045:2: rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0_in_rule__InstanceCreationTuple__Group_2__0__Impl20787);

+            rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group_2__0__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group_2__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10055:1: rule__InstanceCreationTuple__Group_2__1 : rule__InstanceCreationTuple__Group_2__1__Impl ;

+    public final void rule__InstanceCreationTuple__Group_2__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10059:1: ( rule__InstanceCreationTuple__Group_2__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10060:2: rule__InstanceCreationTuple__Group_2__1__Impl

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group_2__1__Impl_in_rule__InstanceCreationTuple__Group_2__120817);

+            rule__InstanceCreationTuple__Group_2__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group_2__1"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group_2__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10066:1: rule__InstanceCreationTuple__Group_2__1__Impl : ( ( rule__InstanceCreationTuple__Group_2_1__0 )* ) ;

+    public final void rule__InstanceCreationTuple__Group_2__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10070:1: ( ( ( rule__InstanceCreationTuple__Group_2_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10071:1: ( ( rule__InstanceCreationTuple__Group_2_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10071:1: ( ( rule__InstanceCreationTuple__Group_2_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10072:1: ( rule__InstanceCreationTuple__Group_2_1__0 )*

+            {

+             before(grammarAccess.getInstanceCreationTupleAccess().getGroup_2_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10073:1: ( rule__InstanceCreationTuple__Group_2_1__0 )*

+            loop83:

+            do {

+                int alt83=2;

+                int LA83_0 = input.LA(1);

+

+                if ( (LA83_0==66) ) {

+                    alt83=1;

+                }

+

+

+                switch (alt83) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10073:2: rule__InstanceCreationTuple__Group_2_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__InstanceCreationTuple__Group_2_1__0_in_rule__InstanceCreationTuple__Group_2__1__Impl20844);

+            	    rule__InstanceCreationTuple__Group_2_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop83;

+                }

+            } while (true);

+

+             after(grammarAccess.getInstanceCreationTupleAccess().getGroup_2_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group_2__1__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group_2_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10087:1: rule__InstanceCreationTuple__Group_2_1__0 : rule__InstanceCreationTuple__Group_2_1__0__Impl rule__InstanceCreationTuple__Group_2_1__1 ;

+    public final void rule__InstanceCreationTuple__Group_2_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10091:1: ( rule__InstanceCreationTuple__Group_2_1__0__Impl rule__InstanceCreationTuple__Group_2_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10092:2: rule__InstanceCreationTuple__Group_2_1__0__Impl rule__InstanceCreationTuple__Group_2_1__1

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group_2_1__0__Impl_in_rule__InstanceCreationTuple__Group_2_1__020879);

+            rule__InstanceCreationTuple__Group_2_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group_2_1__1_in_rule__InstanceCreationTuple__Group_2_1__020882);

+            rule__InstanceCreationTuple__Group_2_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group_2_1__0"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group_2_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10099:1: rule__InstanceCreationTuple__Group_2_1__0__Impl : ( ',' ) ;

+    public final void rule__InstanceCreationTuple__Group_2_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10103:1: ( ( ',' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10104:1: ( ',' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10104:1: ( ',' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10105:1: ','

+            {

+             before(grammarAccess.getInstanceCreationTupleAccess().getCommaKeyword_2_1_0()); 

+            match(input,66,FOLLOW_66_in_rule__InstanceCreationTuple__Group_2_1__0__Impl20910); 

+             after(grammarAccess.getInstanceCreationTupleAccess().getCommaKeyword_2_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group_2_1__0__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group_2_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10118:1: rule__InstanceCreationTuple__Group_2_1__1 : rule__InstanceCreationTuple__Group_2_1__1__Impl ;

+    public final void rule__InstanceCreationTuple__Group_2_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10122:1: ( rule__InstanceCreationTuple__Group_2_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10123:2: rule__InstanceCreationTuple__Group_2_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__Group_2_1__1__Impl_in_rule__InstanceCreationTuple__Group_2_1__120941);

+            rule__InstanceCreationTuple__Group_2_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group_2_1__1"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__Group_2_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10129:1: rule__InstanceCreationTuple__Group_2_1__1__Impl : ( ( rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1 ) ) ;

+    public final void rule__InstanceCreationTuple__Group_2_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10133:1: ( ( ( rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10134:1: ( ( rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10134:1: ( ( rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10135:1: ( rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1 )

+            {

+             before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10136:1: ( rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10136:2: rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1_in_rule__InstanceCreationTuple__Group_2_1__1__Impl20968);

+            rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementAssignment_2_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__Group_2_1__1__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationTupleElement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10150:1: rule__InstanceCreationTupleElement__Group__0 : rule__InstanceCreationTupleElement__Group__0__Impl rule__InstanceCreationTupleElement__Group__1 ;

+    public final void rule__InstanceCreationTupleElement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10154:1: ( rule__InstanceCreationTupleElement__Group__0__Impl rule__InstanceCreationTupleElement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10155:2: rule__InstanceCreationTupleElement__Group__0__Impl rule__InstanceCreationTupleElement__Group__1

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTupleElement__Group__0__Impl_in_rule__InstanceCreationTupleElement__Group__021002);

+            rule__InstanceCreationTupleElement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InstanceCreationTupleElement__Group__1_in_rule__InstanceCreationTupleElement__Group__021005);

+            rule__InstanceCreationTupleElement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTupleElement__Group__0"

+

+

+    // $ANTLR start "rule__InstanceCreationTupleElement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10162:1: rule__InstanceCreationTupleElement__Group__0__Impl : ( ( rule__InstanceCreationTupleElement__RoleAssignment_0 ) ) ;

+    public final void rule__InstanceCreationTupleElement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10166:1: ( ( ( rule__InstanceCreationTupleElement__RoleAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10167:1: ( ( rule__InstanceCreationTupleElement__RoleAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10167:1: ( ( rule__InstanceCreationTupleElement__RoleAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10168:1: ( rule__InstanceCreationTupleElement__RoleAssignment_0 )

+            {

+             before(grammarAccess.getInstanceCreationTupleElementAccess().getRoleAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10169:1: ( rule__InstanceCreationTupleElement__RoleAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10169:2: rule__InstanceCreationTupleElement__RoleAssignment_0

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTupleElement__RoleAssignment_0_in_rule__InstanceCreationTupleElement__Group__0__Impl21032);

+            rule__InstanceCreationTupleElement__RoleAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInstanceCreationTupleElementAccess().getRoleAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTupleElement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationTupleElement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10179:1: rule__InstanceCreationTupleElement__Group__1 : rule__InstanceCreationTupleElement__Group__1__Impl rule__InstanceCreationTupleElement__Group__2 ;

+    public final void rule__InstanceCreationTupleElement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10183:1: ( rule__InstanceCreationTupleElement__Group__1__Impl rule__InstanceCreationTupleElement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10184:2: rule__InstanceCreationTupleElement__Group__1__Impl rule__InstanceCreationTupleElement__Group__2

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTupleElement__Group__1__Impl_in_rule__InstanceCreationTupleElement__Group__121062);

+            rule__InstanceCreationTupleElement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InstanceCreationTupleElement__Group__2_in_rule__InstanceCreationTupleElement__Group__121065);

+            rule__InstanceCreationTupleElement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTupleElement__Group__1"

+

+

+    // $ANTLR start "rule__InstanceCreationTupleElement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10191:1: rule__InstanceCreationTupleElement__Group__1__Impl : ( '=>' ) ;

+    public final void rule__InstanceCreationTupleElement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10195:1: ( ( '=>' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10196:1: ( '=>' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10196:1: ( '=>' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10197:1: '=>'

+            {

+             before(grammarAccess.getInstanceCreationTupleElementAccess().getEqualsSignGreaterThanSignKeyword_1()); 

+            match(input,67,FOLLOW_67_in_rule__InstanceCreationTupleElement__Group__1__Impl21093); 

+             after(grammarAccess.getInstanceCreationTupleElementAccess().getEqualsSignGreaterThanSignKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTupleElement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationTupleElement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10210:1: rule__InstanceCreationTupleElement__Group__2 : rule__InstanceCreationTupleElement__Group__2__Impl ;

+    public final void rule__InstanceCreationTupleElement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10214:1: ( rule__InstanceCreationTupleElement__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10215:2: rule__InstanceCreationTupleElement__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTupleElement__Group__2__Impl_in_rule__InstanceCreationTupleElement__Group__221124);

+            rule__InstanceCreationTupleElement__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTupleElement__Group__2"

+

+

+    // $ANTLR start "rule__InstanceCreationTupleElement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10221:1: rule__InstanceCreationTupleElement__Group__2__Impl : ( ( rule__InstanceCreationTupleElement__ObjectAssignment_2 ) ) ;

+    public final void rule__InstanceCreationTupleElement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10225:1: ( ( ( rule__InstanceCreationTupleElement__ObjectAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10226:1: ( ( rule__InstanceCreationTupleElement__ObjectAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10226:1: ( ( rule__InstanceCreationTupleElement__ObjectAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10227:1: ( rule__InstanceCreationTupleElement__ObjectAssignment_2 )

+            {

+             before(grammarAccess.getInstanceCreationTupleElementAccess().getObjectAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10228:1: ( rule__InstanceCreationTupleElement__ObjectAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10228:2: rule__InstanceCreationTupleElement__ObjectAssignment_2

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationTupleElement__ObjectAssignment_2_in_rule__InstanceCreationTupleElement__Group__2__Impl21151);

+            rule__InstanceCreationTupleElement__ObjectAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInstanceCreationTupleElementAccess().getObjectAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTupleElement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__SequenceConstructionOrAccessCompletion__Group_0__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10244:1: rule__SequenceConstructionOrAccessCompletion__Group_0__0 : rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl rule__SequenceConstructionOrAccessCompletion__Group_0__1 ;

+    public final void rule__SequenceConstructionOrAccessCompletion__Group_0__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10248:1: ( rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl rule__SequenceConstructionOrAccessCompletion__Group_0__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10249:2: rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl rule__SequenceConstructionOrAccessCompletion__Group_0__1

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl_in_rule__SequenceConstructionOrAccessCompletion__Group_0__021187);

+            rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequenceConstructionOrAccessCompletion__Group_0__1_in_rule__SequenceConstructionOrAccessCompletion__Group_0__021190);

+            rule__SequenceConstructionOrAccessCompletion__Group_0__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionOrAccessCompletion__Group_0__0"

+

+

+    // $ANTLR start "rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10256:1: rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl : ( ( rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0 ) ) ;

+    public final void rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10260:1: ( ( ( rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10261:1: ( ( rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10261:1: ( ( rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10262:1: ( rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0 )

+            {

+             before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorAssignment_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10263:1: ( rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10263:2: rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0_in_rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl21217);

+            rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorAssignment_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl"

+

+

+    // $ANTLR start "rule__SequenceConstructionOrAccessCompletion__Group_0__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10273:1: rule__SequenceConstructionOrAccessCompletion__Group_0__1 : rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl ;

+    public final void rule__SequenceConstructionOrAccessCompletion__Group_0__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10277:1: ( rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10278:2: rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl_in_rule__SequenceConstructionOrAccessCompletion__Group_0__121247);

+            rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionOrAccessCompletion__Group_0__1"

+

+

+    // $ANTLR start "rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10284:1: rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl : ( ( rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1 ) ) ;

+    public final void rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10288:1: ( ( ( rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10289:1: ( ( rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10289:1: ( ( rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10290:1: ( rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1 )

+            {

+             before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives_0_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10291:1: ( rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10291:2: rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1_in_rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl21274);

+            rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAlternatives_0_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl"

+

+

+    // $ANTLR start "rule__AccessCompletion__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10305:1: rule__AccessCompletion__Group__0 : rule__AccessCompletion__Group__0__Impl rule__AccessCompletion__Group__1 ;

+    public final void rule__AccessCompletion__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10309:1: ( rule__AccessCompletion__Group__0__Impl rule__AccessCompletion__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10310:2: rule__AccessCompletion__Group__0__Impl rule__AccessCompletion__Group__1

+            {

+            pushFollow(FOLLOW_rule__AccessCompletion__Group__0__Impl_in_rule__AccessCompletion__Group__021308);

+            rule__AccessCompletion__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AccessCompletion__Group__1_in_rule__AccessCompletion__Group__021311);

+            rule__AccessCompletion__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AccessCompletion__Group__0"

+

+

+    // $ANTLR start "rule__AccessCompletion__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10317:1: rule__AccessCompletion__Group__0__Impl : ( ( rule__AccessCompletion__AccessIndexAssignment_0 ) ) ;

+    public final void rule__AccessCompletion__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10321:1: ( ( ( rule__AccessCompletion__AccessIndexAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10322:1: ( ( rule__AccessCompletion__AccessIndexAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10322:1: ( ( rule__AccessCompletion__AccessIndexAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10323:1: ( rule__AccessCompletion__AccessIndexAssignment_0 )

+            {

+             before(grammarAccess.getAccessCompletionAccess().getAccessIndexAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10324:1: ( rule__AccessCompletion__AccessIndexAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10324:2: rule__AccessCompletion__AccessIndexAssignment_0

+            {

+            pushFollow(FOLLOW_rule__AccessCompletion__AccessIndexAssignment_0_in_rule__AccessCompletion__Group__0__Impl21338);

+            rule__AccessCompletion__AccessIndexAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAccessCompletionAccess().getAccessIndexAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AccessCompletion__Group__0__Impl"

+

+

+    // $ANTLR start "rule__AccessCompletion__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10334:1: rule__AccessCompletion__Group__1 : rule__AccessCompletion__Group__1__Impl ;

+    public final void rule__AccessCompletion__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10338:1: ( rule__AccessCompletion__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10339:2: rule__AccessCompletion__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__AccessCompletion__Group__1__Impl_in_rule__AccessCompletion__Group__121368);

+            rule__AccessCompletion__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AccessCompletion__Group__1"

+

+

+    // $ANTLR start "rule__AccessCompletion__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10345:1: rule__AccessCompletion__Group__1__Impl : ( ']' ) ;

+    public final void rule__AccessCompletion__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10349:1: ( ( ']' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10350:1: ( ']' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10350:1: ( ']' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10351:1: ']'

+            {

+             before(grammarAccess.getAccessCompletionAccess().getRightSquareBracketKeyword_1()); 

+            match(input,79,FOLLOW_79_in_rule__AccessCompletion__Group__1__Impl21396); 

+             after(grammarAccess.getAccessCompletionAccess().getRightSquareBracketKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AccessCompletion__Group__1__Impl"

+

+

+    // $ANTLR start "rule__PartialSequenceConstructionCompletion__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10368:1: rule__PartialSequenceConstructionCompletion__Group__0 : rule__PartialSequenceConstructionCompletion__Group__0__Impl rule__PartialSequenceConstructionCompletion__Group__1 ;

+    public final void rule__PartialSequenceConstructionCompletion__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10372:1: ( rule__PartialSequenceConstructionCompletion__Group__0__Impl rule__PartialSequenceConstructionCompletion__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10373:2: rule__PartialSequenceConstructionCompletion__Group__0__Impl rule__PartialSequenceConstructionCompletion__Group__1

+            {

+            pushFollow(FOLLOW_rule__PartialSequenceConstructionCompletion__Group__0__Impl_in_rule__PartialSequenceConstructionCompletion__Group__021431);

+            rule__PartialSequenceConstructionCompletion__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__PartialSequenceConstructionCompletion__Group__1_in_rule__PartialSequenceConstructionCompletion__Group__021434);

+            rule__PartialSequenceConstructionCompletion__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PartialSequenceConstructionCompletion__Group__0"

+

+

+    // $ANTLR start "rule__PartialSequenceConstructionCompletion__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10380:1: rule__PartialSequenceConstructionCompletion__Group__0__Impl : ( ']' ) ;

+    public final void rule__PartialSequenceConstructionCompletion__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10384:1: ( ( ']' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10385:1: ( ']' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10385:1: ( ']' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10386:1: ']'

+            {

+             before(grammarAccess.getPartialSequenceConstructionCompletionAccess().getRightSquareBracketKeyword_0()); 

+            match(input,79,FOLLOW_79_in_rule__PartialSequenceConstructionCompletion__Group__0__Impl21462); 

+             after(grammarAccess.getPartialSequenceConstructionCompletionAccess().getRightSquareBracketKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PartialSequenceConstructionCompletion__Group__0__Impl"

+

+

+    // $ANTLR start "rule__PartialSequenceConstructionCompletion__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10399:1: rule__PartialSequenceConstructionCompletion__Group__1 : rule__PartialSequenceConstructionCompletion__Group__1__Impl ;

+    public final void rule__PartialSequenceConstructionCompletion__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10403:1: ( rule__PartialSequenceConstructionCompletion__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10404:2: rule__PartialSequenceConstructionCompletion__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__PartialSequenceConstructionCompletion__Group__1__Impl_in_rule__PartialSequenceConstructionCompletion__Group__121493);

+            rule__PartialSequenceConstructionCompletion__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PartialSequenceConstructionCompletion__Group__1"

+

+

+    // $ANTLR start "rule__PartialSequenceConstructionCompletion__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10410:1: rule__PartialSequenceConstructionCompletion__Group__1__Impl : ( ( rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1 ) ) ;

+    public final void rule__PartialSequenceConstructionCompletion__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10414:1: ( ( ( rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10415:1: ( ( rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10415:1: ( ( rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10416:1: ( rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1 )

+            {

+             before(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10417:1: ( rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10417:2: rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1

+            {

+            pushFollow(FOLLOW_rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1_in_rule__PartialSequenceConstructionCompletion__Group__1__Impl21520);

+            rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PartialSequenceConstructionCompletion__Group__1__Impl"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10431:1: rule__SequenceConstructionExpression__Group__0 : rule__SequenceConstructionExpression__Group__0__Impl rule__SequenceConstructionExpression__Group__1 ;

+    public final void rule__SequenceConstructionExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10435:1: ( rule__SequenceConstructionExpression__Group__0__Impl rule__SequenceConstructionExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10436:2: rule__SequenceConstructionExpression__Group__0__Impl rule__SequenceConstructionExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group__0__Impl_in_rule__SequenceConstructionExpression__Group__021554);

+            rule__SequenceConstructionExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group__1_in_rule__SequenceConstructionExpression__Group__021557);

+            rule__SequenceConstructionExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group__0"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10443:1: rule__SequenceConstructionExpression__Group__0__Impl : ( '{' ) ;

+    public final void rule__SequenceConstructionExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10447:1: ( ( '{' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10448:1: ( '{' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10448:1: ( '{' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10449:1: '{'

+            {

+             before(grammarAccess.getSequenceConstructionExpressionAccess().getLeftCurlyBracketKeyword_0()); 

+            match(input,87,FOLLOW_87_in_rule__SequenceConstructionExpression__Group__0__Impl21585); 

+             after(grammarAccess.getSequenceConstructionExpressionAccess().getLeftCurlyBracketKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10462:1: rule__SequenceConstructionExpression__Group__1 : rule__SequenceConstructionExpression__Group__1__Impl rule__SequenceConstructionExpression__Group__2 ;

+    public final void rule__SequenceConstructionExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10466:1: ( rule__SequenceConstructionExpression__Group__1__Impl rule__SequenceConstructionExpression__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10467:2: rule__SequenceConstructionExpression__Group__1__Impl rule__SequenceConstructionExpression__Group__2

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group__1__Impl_in_rule__SequenceConstructionExpression__Group__121616);

+            rule__SequenceConstructionExpression__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group__2_in_rule__SequenceConstructionExpression__Group__121619);

+            rule__SequenceConstructionExpression__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group__1"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10474:1: rule__SequenceConstructionExpression__Group__1__Impl : ( ( rule__SequenceConstructionExpression__SequenceElementAssignment_1 ) ) ;

+    public final void rule__SequenceConstructionExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10478:1: ( ( ( rule__SequenceConstructionExpression__SequenceElementAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10479:1: ( ( rule__SequenceConstructionExpression__SequenceElementAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10479:1: ( ( rule__SequenceConstructionExpression__SequenceElementAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10480:1: ( rule__SequenceConstructionExpression__SequenceElementAssignment_1 )

+            {

+             before(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10481:1: ( rule__SequenceConstructionExpression__SequenceElementAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10481:2: rule__SequenceConstructionExpression__SequenceElementAssignment_1

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__SequenceElementAssignment_1_in_rule__SequenceConstructionExpression__Group__1__Impl21646);

+            rule__SequenceConstructionExpression__SequenceElementAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10491:1: rule__SequenceConstructionExpression__Group__2 : rule__SequenceConstructionExpression__Group__2__Impl rule__SequenceConstructionExpression__Group__3 ;

+    public final void rule__SequenceConstructionExpression__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10495:1: ( rule__SequenceConstructionExpression__Group__2__Impl rule__SequenceConstructionExpression__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10496:2: rule__SequenceConstructionExpression__Group__2__Impl rule__SequenceConstructionExpression__Group__3

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group__2__Impl_in_rule__SequenceConstructionExpression__Group__221676);

+            rule__SequenceConstructionExpression__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group__3_in_rule__SequenceConstructionExpression__Group__221679);

+            rule__SequenceConstructionExpression__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group__2"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10503:1: rule__SequenceConstructionExpression__Group__2__Impl : ( ( rule__SequenceConstructionExpression__Alternatives_2 ) ) ;

+    public final void rule__SequenceConstructionExpression__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10507:1: ( ( ( rule__SequenceConstructionExpression__Alternatives_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10508:1: ( ( rule__SequenceConstructionExpression__Alternatives_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10508:1: ( ( rule__SequenceConstructionExpression__Alternatives_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10509:1: ( rule__SequenceConstructionExpression__Alternatives_2 )

+            {

+             before(grammarAccess.getSequenceConstructionExpressionAccess().getAlternatives_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10510:1: ( rule__SequenceConstructionExpression__Alternatives_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10510:2: rule__SequenceConstructionExpression__Alternatives_2

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Alternatives_2_in_rule__SequenceConstructionExpression__Group__2__Impl21706);

+            rule__SequenceConstructionExpression__Alternatives_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceConstructionExpressionAccess().getAlternatives_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group__2__Impl"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10520:1: rule__SequenceConstructionExpression__Group__3 : rule__SequenceConstructionExpression__Group__3__Impl ;

+    public final void rule__SequenceConstructionExpression__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10524:1: ( rule__SequenceConstructionExpression__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10525:2: rule__SequenceConstructionExpression__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group__3__Impl_in_rule__SequenceConstructionExpression__Group__321736);

+            rule__SequenceConstructionExpression__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group__3"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10531:1: rule__SequenceConstructionExpression__Group__3__Impl : ( '}' ) ;

+    public final void rule__SequenceConstructionExpression__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10535:1: ( ( '}' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10536:1: ( '}' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10536:1: ( '}' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10537:1: '}'

+            {

+             before(grammarAccess.getSequenceConstructionExpressionAccess().getRightCurlyBracketKeyword_3()); 

+            match(input,88,FOLLOW_88_in_rule__SequenceConstructionExpression__Group__3__Impl21764); 

+             after(grammarAccess.getSequenceConstructionExpressionAccess().getRightCurlyBracketKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group__3__Impl"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group_2_0__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10558:1: rule__SequenceConstructionExpression__Group_2_0__0 : rule__SequenceConstructionExpression__Group_2_0__0__Impl rule__SequenceConstructionExpression__Group_2_0__1 ;

+    public final void rule__SequenceConstructionExpression__Group_2_0__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10562:1: ( rule__SequenceConstructionExpression__Group_2_0__0__Impl rule__SequenceConstructionExpression__Group_2_0__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10563:2: rule__SequenceConstructionExpression__Group_2_0__0__Impl rule__SequenceConstructionExpression__Group_2_0__1

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group_2_0__0__Impl_in_rule__SequenceConstructionExpression__Group_2_0__021803);

+            rule__SequenceConstructionExpression__Group_2_0__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group_2_0__1_in_rule__SequenceConstructionExpression__Group_2_0__021806);

+            rule__SequenceConstructionExpression__Group_2_0__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group_2_0__0"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group_2_0__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10570:1: rule__SequenceConstructionExpression__Group_2_0__0__Impl : ( ',' ) ;

+    public final void rule__SequenceConstructionExpression__Group_2_0__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10574:1: ( ( ',' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10575:1: ( ',' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10575:1: ( ',' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10576:1: ','

+            {

+             before(grammarAccess.getSequenceConstructionExpressionAccess().getCommaKeyword_2_0_0()); 

+            match(input,66,FOLLOW_66_in_rule__SequenceConstructionExpression__Group_2_0__0__Impl21834); 

+             after(grammarAccess.getSequenceConstructionExpressionAccess().getCommaKeyword_2_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group_2_0__0__Impl"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group_2_0__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10589:1: rule__SequenceConstructionExpression__Group_2_0__1 : rule__SequenceConstructionExpression__Group_2_0__1__Impl ;

+    public final void rule__SequenceConstructionExpression__Group_2_0__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10593:1: ( rule__SequenceConstructionExpression__Group_2_0__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10594:2: rule__SequenceConstructionExpression__Group_2_0__1__Impl

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group_2_0__1__Impl_in_rule__SequenceConstructionExpression__Group_2_0__121865);

+            rule__SequenceConstructionExpression__Group_2_0__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group_2_0__1"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group_2_0__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10600:1: rule__SequenceConstructionExpression__Group_2_0__1__Impl : ( ( rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1 ) ) ;

+    public final void rule__SequenceConstructionExpression__Group_2_0__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10604:1: ( ( ( rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10605:1: ( ( rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10605:1: ( ( rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10606:1: ( rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1 )

+            {

+             before(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_2_0_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10607:1: ( rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10607:2: rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1_in_rule__SequenceConstructionExpression__Group_2_0__1__Impl21892);

+            rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementAssignment_2_0_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group_2_0__1__Impl"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group_2_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10621:1: rule__SequenceConstructionExpression__Group_2_1__0 : rule__SequenceConstructionExpression__Group_2_1__0__Impl rule__SequenceConstructionExpression__Group_2_1__1 ;

+    public final void rule__SequenceConstructionExpression__Group_2_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10625:1: ( rule__SequenceConstructionExpression__Group_2_1__0__Impl rule__SequenceConstructionExpression__Group_2_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10626:2: rule__SequenceConstructionExpression__Group_2_1__0__Impl rule__SequenceConstructionExpression__Group_2_1__1

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group_2_1__0__Impl_in_rule__SequenceConstructionExpression__Group_2_1__021926);

+            rule__SequenceConstructionExpression__Group_2_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group_2_1__1_in_rule__SequenceConstructionExpression__Group_2_1__021929);

+            rule__SequenceConstructionExpression__Group_2_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group_2_1__0"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group_2_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10633:1: rule__SequenceConstructionExpression__Group_2_1__0__Impl : ( '..' ) ;

+    public final void rule__SequenceConstructionExpression__Group_2_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10637:1: ( ( '..' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10638:1: ( '..' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10638:1: ( '..' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10639:1: '..'

+            {

+             before(grammarAccess.getSequenceConstructionExpressionAccess().getFullStopFullStopKeyword_2_1_0()); 

+            match(input,89,FOLLOW_89_in_rule__SequenceConstructionExpression__Group_2_1__0__Impl21957); 

+             after(grammarAccess.getSequenceConstructionExpressionAccess().getFullStopFullStopKeyword_2_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group_2_1__0__Impl"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group_2_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10652:1: rule__SequenceConstructionExpression__Group_2_1__1 : rule__SequenceConstructionExpression__Group_2_1__1__Impl ;

+    public final void rule__SequenceConstructionExpression__Group_2_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10656:1: ( rule__SequenceConstructionExpression__Group_2_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10657:2: rule__SequenceConstructionExpression__Group_2_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__Group_2_1__1__Impl_in_rule__SequenceConstructionExpression__Group_2_1__121988);

+            rule__SequenceConstructionExpression__Group_2_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group_2_1__1"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__Group_2_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10663:1: rule__SequenceConstructionExpression__Group_2_1__1__Impl : ( ( rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1 ) ) ;

+    public final void rule__SequenceConstructionExpression__Group_2_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10667:1: ( ( ( rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10668:1: ( ( rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10668:1: ( ( rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10669:1: ( rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1 )

+            {

+             before(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperAssignment_2_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10670:1: ( rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10670:2: rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1

+            {

+            pushFollow(FOLLOW_rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1_in_rule__SequenceConstructionExpression__Group_2_1__1__Impl22015);

+            rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperAssignment_2_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__Group_2_1__1__Impl"

+

+

+    // $ANTLR start "rule__ClassExtentExpression__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10684:1: rule__ClassExtentExpression__Group__0 : rule__ClassExtentExpression__Group__0__Impl rule__ClassExtentExpression__Group__1 ;

+    public final void rule__ClassExtentExpression__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10688:1: ( rule__ClassExtentExpression__Group__0__Impl rule__ClassExtentExpression__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10689:2: rule__ClassExtentExpression__Group__0__Impl rule__ClassExtentExpression__Group__1

+            {

+            pushFollow(FOLLOW_rule__ClassExtentExpression__Group__0__Impl_in_rule__ClassExtentExpression__Group__022049);

+            rule__ClassExtentExpression__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ClassExtentExpression__Group__1_in_rule__ClassExtentExpression__Group__022052);

+            rule__ClassExtentExpression__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassExtentExpression__Group__0"

+

+

+    // $ANTLR start "rule__ClassExtentExpression__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10696:1: rule__ClassExtentExpression__Group__0__Impl : ( () ) ;

+    public final void rule__ClassExtentExpression__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10700:1: ( ( () ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10701:1: ( () )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10701:1: ( () )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10702:1: ()

+            {

+             before(grammarAccess.getClassExtentExpressionAccess().getClassExtentExpressionAction_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10703:1: ()

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10705:1: 

+            {

+            }

+

+             after(grammarAccess.getClassExtentExpressionAccess().getClassExtentExpressionAction_0()); 

+

+            }

+

+

+            }

+

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassExtentExpression__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ClassExtentExpression__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10715:1: rule__ClassExtentExpression__Group__1 : rule__ClassExtentExpression__Group__1__Impl rule__ClassExtentExpression__Group__2 ;

+    public final void rule__ClassExtentExpression__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10719:1: ( rule__ClassExtentExpression__Group__1__Impl rule__ClassExtentExpression__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10720:2: rule__ClassExtentExpression__Group__1__Impl rule__ClassExtentExpression__Group__2

+            {

+            pushFollow(FOLLOW_rule__ClassExtentExpression__Group__1__Impl_in_rule__ClassExtentExpression__Group__122110);

+            rule__ClassExtentExpression__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ClassExtentExpression__Group__2_in_rule__ClassExtentExpression__Group__122113);

+            rule__ClassExtentExpression__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassExtentExpression__Group__1"

+

+

+    // $ANTLR start "rule__ClassExtentExpression__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10727:1: rule__ClassExtentExpression__Group__1__Impl : ( '.' ) ;

+    public final void rule__ClassExtentExpression__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10731:1: ( ( '.' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10732:1: ( '.' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10732:1: ( '.' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10733:1: '.'

+            {

+             before(grammarAccess.getClassExtentExpressionAccess().getFullStopKeyword_1()); 

+            match(input,77,FOLLOW_77_in_rule__ClassExtentExpression__Group__1__Impl22141); 

+             after(grammarAccess.getClassExtentExpressionAccess().getFullStopKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassExtentExpression__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ClassExtentExpression__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10746:1: rule__ClassExtentExpression__Group__2 : rule__ClassExtentExpression__Group__2__Impl rule__ClassExtentExpression__Group__3 ;

+    public final void rule__ClassExtentExpression__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10750:1: ( rule__ClassExtentExpression__Group__2__Impl rule__ClassExtentExpression__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10751:2: rule__ClassExtentExpression__Group__2__Impl rule__ClassExtentExpression__Group__3

+            {

+            pushFollow(FOLLOW_rule__ClassExtentExpression__Group__2__Impl_in_rule__ClassExtentExpression__Group__222172);

+            rule__ClassExtentExpression__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ClassExtentExpression__Group__3_in_rule__ClassExtentExpression__Group__222175);

+            rule__ClassExtentExpression__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassExtentExpression__Group__2"

+

+

+    // $ANTLR start "rule__ClassExtentExpression__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10758:1: rule__ClassExtentExpression__Group__2__Impl : ( 'allInstances' ) ;

+    public final void rule__ClassExtentExpression__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10762:1: ( ( 'allInstances' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10763:1: ( 'allInstances' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10763:1: ( 'allInstances' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10764:1: 'allInstances'

+            {

+             before(grammarAccess.getClassExtentExpressionAccess().getAllInstancesKeyword_2()); 

+            match(input,90,FOLLOW_90_in_rule__ClassExtentExpression__Group__2__Impl22203); 

+             after(grammarAccess.getClassExtentExpressionAccess().getAllInstancesKeyword_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassExtentExpression__Group__2__Impl"

+

+

+    // $ANTLR start "rule__ClassExtentExpression__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10777:1: rule__ClassExtentExpression__Group__3 : rule__ClassExtentExpression__Group__3__Impl rule__ClassExtentExpression__Group__4 ;

+    public final void rule__ClassExtentExpression__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10781:1: ( rule__ClassExtentExpression__Group__3__Impl rule__ClassExtentExpression__Group__4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10782:2: rule__ClassExtentExpression__Group__3__Impl rule__ClassExtentExpression__Group__4

+            {

+            pushFollow(FOLLOW_rule__ClassExtentExpression__Group__3__Impl_in_rule__ClassExtentExpression__Group__322234);

+            rule__ClassExtentExpression__Group__3__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ClassExtentExpression__Group__4_in_rule__ClassExtentExpression__Group__322237);

+            rule__ClassExtentExpression__Group__4();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassExtentExpression__Group__3"

+

+

+    // $ANTLR start "rule__ClassExtentExpression__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10789:1: rule__ClassExtentExpression__Group__3__Impl : ( '(' ) ;

+    public final void rule__ClassExtentExpression__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10793:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10794:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10794:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10795:1: '('

+            {

+             before(grammarAccess.getClassExtentExpressionAccess().getLeftParenthesisKeyword_3()); 

+            match(input,68,FOLLOW_68_in_rule__ClassExtentExpression__Group__3__Impl22265); 

+             after(grammarAccess.getClassExtentExpressionAccess().getLeftParenthesisKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassExtentExpression__Group__3__Impl"

+

+

+    // $ANTLR start "rule__ClassExtentExpression__Group__4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10808:1: rule__ClassExtentExpression__Group__4 : rule__ClassExtentExpression__Group__4__Impl ;

+    public final void rule__ClassExtentExpression__Group__4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10812:1: ( rule__ClassExtentExpression__Group__4__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10813:2: rule__ClassExtentExpression__Group__4__Impl

+            {

+            pushFollow(FOLLOW_rule__ClassExtentExpression__Group__4__Impl_in_rule__ClassExtentExpression__Group__422296);

+            rule__ClassExtentExpression__Group__4__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassExtentExpression__Group__4"

+

+

+    // $ANTLR start "rule__ClassExtentExpression__Group__4__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10819:1: rule__ClassExtentExpression__Group__4__Impl : ( ')' ) ;

+    public final void rule__ClassExtentExpression__Group__4__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10823:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10824:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10824:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10825:1: ')'

+            {

+             before(grammarAccess.getClassExtentExpressionAccess().getRightParenthesisKeyword_4()); 

+            match(input,69,FOLLOW_69_in_rule__ClassExtentExpression__Group__4__Impl22324); 

+             after(grammarAccess.getClassExtentExpressionAccess().getRightParenthesisKeyword_4()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassExtentExpression__Group__4__Impl"

+

+

+    // $ANTLR start "rule__Block__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10848:1: rule__Block__Group__0 : rule__Block__Group__0__Impl rule__Block__Group__1 ;

+    public final void rule__Block__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10852:1: ( rule__Block__Group__0__Impl rule__Block__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10853:2: rule__Block__Group__0__Impl rule__Block__Group__1

+            {

+            pushFollow(FOLLOW_rule__Block__Group__0__Impl_in_rule__Block__Group__022365);

+            rule__Block__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Block__Group__1_in_rule__Block__Group__022368);

+            rule__Block__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Block__Group__0"

+

+

+    // $ANTLR start "rule__Block__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10860:1: rule__Block__Group__0__Impl : ( '{' ) ;

+    public final void rule__Block__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10864:1: ( ( '{' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10865:1: ( '{' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10865:1: ( '{' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10866:1: '{'

+            {

+             before(grammarAccess.getBlockAccess().getLeftCurlyBracketKeyword_0()); 

+            match(input,87,FOLLOW_87_in_rule__Block__Group__0__Impl22396); 

+             after(grammarAccess.getBlockAccess().getLeftCurlyBracketKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Block__Group__0__Impl"

+

+

+    // $ANTLR start "rule__Block__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10879:1: rule__Block__Group__1 : rule__Block__Group__1__Impl rule__Block__Group__2 ;

+    public final void rule__Block__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10883:1: ( rule__Block__Group__1__Impl rule__Block__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10884:2: rule__Block__Group__1__Impl rule__Block__Group__2

+            {

+            pushFollow(FOLLOW_rule__Block__Group__1__Impl_in_rule__Block__Group__122427);

+            rule__Block__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Block__Group__2_in_rule__Block__Group__122430);

+            rule__Block__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Block__Group__1"

+

+

+    // $ANTLR start "rule__Block__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10891:1: rule__Block__Group__1__Impl : ( () ) ;

+    public final void rule__Block__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10895:1: ( ( () ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10896:1: ( () )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10896:1: ( () )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10897:1: ()

+            {

+             before(grammarAccess.getBlockAccess().getBlockAction_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10898:1: ()

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10900:1: 

+            {

+            }

+

+             after(grammarAccess.getBlockAccess().getBlockAction_1()); 

+

+            }

+

+

+            }

+

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Block__Group__1__Impl"

+

+

+    // $ANTLR start "rule__Block__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10910:1: rule__Block__Group__2 : rule__Block__Group__2__Impl rule__Block__Group__3 ;

+    public final void rule__Block__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10914:1: ( rule__Block__Group__2__Impl rule__Block__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10915:2: rule__Block__Group__2__Impl rule__Block__Group__3

+            {

+            pushFollow(FOLLOW_rule__Block__Group__2__Impl_in_rule__Block__Group__222488);

+            rule__Block__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Block__Group__3_in_rule__Block__Group__222491);

+            rule__Block__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Block__Group__2"

+

+

+    // $ANTLR start "rule__Block__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10922:1: rule__Block__Group__2__Impl : ( ( rule__Block__SequenceAssignment_2 )? ) ;

+    public final void rule__Block__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10926:1: ( ( ( rule__Block__SequenceAssignment_2 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10927:1: ( ( rule__Block__SequenceAssignment_2 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10927:1: ( ( rule__Block__SequenceAssignment_2 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10928:1: ( rule__Block__SequenceAssignment_2 )?

+            {

+             before(grammarAccess.getBlockAccess().getSequenceAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10929:1: ( rule__Block__SequenceAssignment_2 )?

+            int alt84=2;

+            int LA84_0 = input.LA(1);

+

+            if ( ((LA84_0>=RULE_ML_COMMENT && LA84_0<=RULE_SL_COMMENT)||LA84_0==RULE_ID||(LA84_0>=12 && LA84_0<=13)||(LA84_0>=84 && LA84_0<=87)||LA84_0==91||(LA84_0>=94 && LA84_0<=97)||LA84_0==100||(LA84_0>=103 && LA84_0<=105)||(LA84_0>=107 && LA84_0<=110)) ) {

+                alt84=1;

+            }

+            switch (alt84) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10929:2: rule__Block__SequenceAssignment_2

+                    {

+                    pushFollow(FOLLOW_rule__Block__SequenceAssignment_2_in_rule__Block__Group__2__Impl22518);

+                    rule__Block__SequenceAssignment_2();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getBlockAccess().getSequenceAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Block__Group__2__Impl"

+

+

+    // $ANTLR start "rule__Block__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10939:1: rule__Block__Group__3 : rule__Block__Group__3__Impl ;

+    public final void rule__Block__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10943:1: ( rule__Block__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10944:2: rule__Block__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__Block__Group__3__Impl_in_rule__Block__Group__322549);

+            rule__Block__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Block__Group__3"

+

+

+    // $ANTLR start "rule__Block__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10950:1: rule__Block__Group__3__Impl : ( '}' ) ;

+    public final void rule__Block__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10954:1: ( ( '}' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10955:1: ( '}' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10955:1: ( '}' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10956:1: '}'

+            {

+             before(grammarAccess.getBlockAccess().getRightCurlyBracketKeyword_3()); 

+            match(input,88,FOLLOW_88_in_rule__Block__Group__3__Impl22577); 

+             after(grammarAccess.getBlockAccess().getRightCurlyBracketKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Block__Group__3__Impl"

+

+

+    // $ANTLR start "rule__DocumentedStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10977:1: rule__DocumentedStatement__Group__0 : rule__DocumentedStatement__Group__0__Impl rule__DocumentedStatement__Group__1 ;

+    public final void rule__DocumentedStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10981:1: ( rule__DocumentedStatement__Group__0__Impl rule__DocumentedStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10982:2: rule__DocumentedStatement__Group__0__Impl rule__DocumentedStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__DocumentedStatement__Group__0__Impl_in_rule__DocumentedStatement__Group__022616);

+            rule__DocumentedStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__DocumentedStatement__Group__1_in_rule__DocumentedStatement__Group__022619);

+            rule__DocumentedStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DocumentedStatement__Group__0"

+

+

+    // $ANTLR start "rule__DocumentedStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10989:1: rule__DocumentedStatement__Group__0__Impl : ( ( rule__DocumentedStatement__CommentAssignment_0 )? ) ;

+    public final void rule__DocumentedStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10993:1: ( ( ( rule__DocumentedStatement__CommentAssignment_0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10994:1: ( ( rule__DocumentedStatement__CommentAssignment_0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10994:1: ( ( rule__DocumentedStatement__CommentAssignment_0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10995:1: ( rule__DocumentedStatement__CommentAssignment_0 )?

+            {

+             before(grammarAccess.getDocumentedStatementAccess().getCommentAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10996:1: ( rule__DocumentedStatement__CommentAssignment_0 )?

+            int alt85=2;

+            int LA85_0 = input.LA(1);

+

+            if ( ((LA85_0>=RULE_ML_COMMENT && LA85_0<=RULE_SL_COMMENT)) ) {

+                alt85=1;

+            }

+            switch (alt85) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:10996:2: rule__DocumentedStatement__CommentAssignment_0

+                    {

+                    pushFollow(FOLLOW_rule__DocumentedStatement__CommentAssignment_0_in_rule__DocumentedStatement__Group__0__Impl22646);

+                    rule__DocumentedStatement__CommentAssignment_0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getDocumentedStatementAccess().getCommentAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DocumentedStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__DocumentedStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11006:1: rule__DocumentedStatement__Group__1 : rule__DocumentedStatement__Group__1__Impl ;

+    public final void rule__DocumentedStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11010:1: ( rule__DocumentedStatement__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11011:2: rule__DocumentedStatement__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__DocumentedStatement__Group__1__Impl_in_rule__DocumentedStatement__Group__122677);

+            rule__DocumentedStatement__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DocumentedStatement__Group__1"

+

+

+    // $ANTLR start "rule__DocumentedStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11017:1: rule__DocumentedStatement__Group__1__Impl : ( ( rule__DocumentedStatement__StatementAssignment_1 ) ) ;

+    public final void rule__DocumentedStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11021:1: ( ( ( rule__DocumentedStatement__StatementAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11022:1: ( ( rule__DocumentedStatement__StatementAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11022:1: ( ( rule__DocumentedStatement__StatementAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11023:1: ( rule__DocumentedStatement__StatementAssignment_1 )

+            {

+             before(grammarAccess.getDocumentedStatementAccess().getStatementAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11024:1: ( rule__DocumentedStatement__StatementAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11024:2: rule__DocumentedStatement__StatementAssignment_1

+            {

+            pushFollow(FOLLOW_rule__DocumentedStatement__StatementAssignment_1_in_rule__DocumentedStatement__Group__1__Impl22704);

+            rule__DocumentedStatement__StatementAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getDocumentedStatementAccess().getStatementAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DocumentedStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11038:1: rule__InlineStatement__Group__0 : rule__InlineStatement__Group__0__Impl rule__InlineStatement__Group__1 ;

+    public final void rule__InlineStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11042:1: ( rule__InlineStatement__Group__0__Impl rule__InlineStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11043:2: rule__InlineStatement__Group__0__Impl rule__InlineStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__InlineStatement__Group__0__Impl_in_rule__InlineStatement__Group__022738);

+            rule__InlineStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InlineStatement__Group__1_in_rule__InlineStatement__Group__022741);

+            rule__InlineStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__0"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11050:1: rule__InlineStatement__Group__0__Impl : ( '/*@' ) ;

+    public final void rule__InlineStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11054:1: ( ( '/*@' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11055:1: ( '/*@' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11055:1: ( '/*@' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11056:1: '/*@'

+            {

+             before(grammarAccess.getInlineStatementAccess().getSolidusAsteriskCommercialAtKeyword_0()); 

+            match(input,91,FOLLOW_91_in_rule__InlineStatement__Group__0__Impl22769); 

+             after(grammarAccess.getInlineStatementAccess().getSolidusAsteriskCommercialAtKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11069:1: rule__InlineStatement__Group__1 : rule__InlineStatement__Group__1__Impl rule__InlineStatement__Group__2 ;

+    public final void rule__InlineStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11073:1: ( rule__InlineStatement__Group__1__Impl rule__InlineStatement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11074:2: rule__InlineStatement__Group__1__Impl rule__InlineStatement__Group__2

+            {

+            pushFollow(FOLLOW_rule__InlineStatement__Group__1__Impl_in_rule__InlineStatement__Group__122800);

+            rule__InlineStatement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InlineStatement__Group__2_in_rule__InlineStatement__Group__122803);

+            rule__InlineStatement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__1"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11081:1: rule__InlineStatement__Group__1__Impl : ( 'inline' ) ;

+    public final void rule__InlineStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11085:1: ( ( 'inline' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11086:1: ( 'inline' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11086:1: ( 'inline' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11087:1: 'inline'

+            {

+             before(grammarAccess.getInlineStatementAccess().getInlineKeyword_1()); 

+            match(input,92,FOLLOW_92_in_rule__InlineStatement__Group__1__Impl22831); 

+             after(grammarAccess.getInlineStatementAccess().getInlineKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11100:1: rule__InlineStatement__Group__2 : rule__InlineStatement__Group__2__Impl rule__InlineStatement__Group__3 ;

+    public final void rule__InlineStatement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11104:1: ( rule__InlineStatement__Group__2__Impl rule__InlineStatement__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11105:2: rule__InlineStatement__Group__2__Impl rule__InlineStatement__Group__3

+            {

+            pushFollow(FOLLOW_rule__InlineStatement__Group__2__Impl_in_rule__InlineStatement__Group__222862);

+            rule__InlineStatement__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InlineStatement__Group__3_in_rule__InlineStatement__Group__222865);

+            rule__InlineStatement__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__2"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11112:1: rule__InlineStatement__Group__2__Impl : ( '(' ) ;

+    public final void rule__InlineStatement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11116:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11117:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11117:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11118:1: '('

+            {

+             before(grammarAccess.getInlineStatementAccess().getLeftParenthesisKeyword_2()); 

+            match(input,68,FOLLOW_68_in_rule__InlineStatement__Group__2__Impl22893); 

+             after(grammarAccess.getInlineStatementAccess().getLeftParenthesisKeyword_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11131:1: rule__InlineStatement__Group__3 : rule__InlineStatement__Group__3__Impl rule__InlineStatement__Group__4 ;

+    public final void rule__InlineStatement__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11135:1: ( rule__InlineStatement__Group__3__Impl rule__InlineStatement__Group__4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11136:2: rule__InlineStatement__Group__3__Impl rule__InlineStatement__Group__4

+            {

+            pushFollow(FOLLOW_rule__InlineStatement__Group__3__Impl_in_rule__InlineStatement__Group__322924);

+            rule__InlineStatement__Group__3__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InlineStatement__Group__4_in_rule__InlineStatement__Group__322927);

+            rule__InlineStatement__Group__4();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__3"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11143:1: rule__InlineStatement__Group__3__Impl : ( ( rule__InlineStatement__LangageNameAssignment_3 ) ) ;

+    public final void rule__InlineStatement__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11147:1: ( ( ( rule__InlineStatement__LangageNameAssignment_3 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11148:1: ( ( rule__InlineStatement__LangageNameAssignment_3 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11148:1: ( ( rule__InlineStatement__LangageNameAssignment_3 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11149:1: ( rule__InlineStatement__LangageNameAssignment_3 )

+            {

+             before(grammarAccess.getInlineStatementAccess().getLangageNameAssignment_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11150:1: ( rule__InlineStatement__LangageNameAssignment_3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11150:2: rule__InlineStatement__LangageNameAssignment_3

+            {

+            pushFollow(FOLLOW_rule__InlineStatement__LangageNameAssignment_3_in_rule__InlineStatement__Group__3__Impl22954);

+            rule__InlineStatement__LangageNameAssignment_3();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInlineStatementAccess().getLangageNameAssignment_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__3__Impl"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11160:1: rule__InlineStatement__Group__4 : rule__InlineStatement__Group__4__Impl rule__InlineStatement__Group__5 ;

+    public final void rule__InlineStatement__Group__4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11164:1: ( rule__InlineStatement__Group__4__Impl rule__InlineStatement__Group__5 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11165:2: rule__InlineStatement__Group__4__Impl rule__InlineStatement__Group__5

+            {

+            pushFollow(FOLLOW_rule__InlineStatement__Group__4__Impl_in_rule__InlineStatement__Group__422984);

+            rule__InlineStatement__Group__4__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InlineStatement__Group__5_in_rule__InlineStatement__Group__422987);

+            rule__InlineStatement__Group__5();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__4"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__4__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11172:1: rule__InlineStatement__Group__4__Impl : ( ')' ) ;

+    public final void rule__InlineStatement__Group__4__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11176:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11177:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11177:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11178:1: ')'

+            {

+             before(grammarAccess.getInlineStatementAccess().getRightParenthesisKeyword_4()); 

+            match(input,69,FOLLOW_69_in_rule__InlineStatement__Group__4__Impl23015); 

+             after(grammarAccess.getInlineStatementAccess().getRightParenthesisKeyword_4()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__4__Impl"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__5"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11191:1: rule__InlineStatement__Group__5 : rule__InlineStatement__Group__5__Impl rule__InlineStatement__Group__6 ;

+    public final void rule__InlineStatement__Group__5() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11195:1: ( rule__InlineStatement__Group__5__Impl rule__InlineStatement__Group__6 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11196:2: rule__InlineStatement__Group__5__Impl rule__InlineStatement__Group__6

+            {

+            pushFollow(FOLLOW_rule__InlineStatement__Group__5__Impl_in_rule__InlineStatement__Group__523046);

+            rule__InlineStatement__Group__5__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InlineStatement__Group__6_in_rule__InlineStatement__Group__523049);

+            rule__InlineStatement__Group__6();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__5"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__5__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11203:1: rule__InlineStatement__Group__5__Impl : ( ( rule__InlineStatement__BodyAssignment_5 ) ) ;

+    public final void rule__InlineStatement__Group__5__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11207:1: ( ( ( rule__InlineStatement__BodyAssignment_5 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11208:1: ( ( rule__InlineStatement__BodyAssignment_5 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11208:1: ( ( rule__InlineStatement__BodyAssignment_5 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11209:1: ( rule__InlineStatement__BodyAssignment_5 )

+            {

+             before(grammarAccess.getInlineStatementAccess().getBodyAssignment_5()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11210:1: ( rule__InlineStatement__BodyAssignment_5 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11210:2: rule__InlineStatement__BodyAssignment_5

+            {

+            pushFollow(FOLLOW_rule__InlineStatement__BodyAssignment_5_in_rule__InlineStatement__Group__5__Impl23076);

+            rule__InlineStatement__BodyAssignment_5();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInlineStatementAccess().getBodyAssignment_5()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__5__Impl"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11220:1: rule__InlineStatement__Group__6 : rule__InlineStatement__Group__6__Impl ;

+    public final void rule__InlineStatement__Group__6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11224:1: ( rule__InlineStatement__Group__6__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11225:2: rule__InlineStatement__Group__6__Impl

+            {

+            pushFollow(FOLLOW_rule__InlineStatement__Group__6__Impl_in_rule__InlineStatement__Group__623106);

+            rule__InlineStatement__Group__6__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__6"

+

+

+    // $ANTLR start "rule__InlineStatement__Group__6__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11231:1: rule__InlineStatement__Group__6__Impl : ( '*/' ) ;

+    public final void rule__InlineStatement__Group__6__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11235:1: ( ( '*/' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11236:1: ( '*/' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11236:1: ( '*/' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11237:1: '*/'

+            {

+             before(grammarAccess.getInlineStatementAccess().getAsteriskSolidusKeyword_6()); 

+            match(input,93,FOLLOW_93_in_rule__InlineStatement__Group__6__Impl23134); 

+             after(grammarAccess.getInlineStatementAccess().getAsteriskSolidusKeyword_6()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__Group__6__Impl"

+

+

+    // $ANTLR start "rule__AnnotatedStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11264:1: rule__AnnotatedStatement__Group__0 : rule__AnnotatedStatement__Group__0__Impl rule__AnnotatedStatement__Group__1 ;

+    public final void rule__AnnotatedStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11268:1: ( rule__AnnotatedStatement__Group__0__Impl rule__AnnotatedStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11269:2: rule__AnnotatedStatement__Group__0__Impl rule__AnnotatedStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__AnnotatedStatement__Group__0__Impl_in_rule__AnnotatedStatement__Group__023179);

+            rule__AnnotatedStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AnnotatedStatement__Group__1_in_rule__AnnotatedStatement__Group__023182);

+            rule__AnnotatedStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AnnotatedStatement__Group__0"

+

+

+    // $ANTLR start "rule__AnnotatedStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11276:1: rule__AnnotatedStatement__Group__0__Impl : ( '//@' ) ;

+    public final void rule__AnnotatedStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11280:1: ( ( '//@' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11281:1: ( '//@' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11281:1: ( '//@' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11282:1: '//@'

+            {

+             before(grammarAccess.getAnnotatedStatementAccess().getSolidusSolidusCommercialAtKeyword_0()); 

+            match(input,94,FOLLOW_94_in_rule__AnnotatedStatement__Group__0__Impl23210); 

+             after(grammarAccess.getAnnotatedStatementAccess().getSolidusSolidusCommercialAtKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AnnotatedStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__AnnotatedStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11295:1: rule__AnnotatedStatement__Group__1 : rule__AnnotatedStatement__Group__1__Impl rule__AnnotatedStatement__Group__2 ;

+    public final void rule__AnnotatedStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11299:1: ( rule__AnnotatedStatement__Group__1__Impl rule__AnnotatedStatement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11300:2: rule__AnnotatedStatement__Group__1__Impl rule__AnnotatedStatement__Group__2

+            {

+            pushFollow(FOLLOW_rule__AnnotatedStatement__Group__1__Impl_in_rule__AnnotatedStatement__Group__123241);

+            rule__AnnotatedStatement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AnnotatedStatement__Group__2_in_rule__AnnotatedStatement__Group__123244);

+            rule__AnnotatedStatement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AnnotatedStatement__Group__1"

+

+

+    // $ANTLR start "rule__AnnotatedStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11307:1: rule__AnnotatedStatement__Group__1__Impl : ( ( rule__AnnotatedStatement__AnnotationAssignment_1 ) ) ;

+    public final void rule__AnnotatedStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11311:1: ( ( ( rule__AnnotatedStatement__AnnotationAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11312:1: ( ( rule__AnnotatedStatement__AnnotationAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11312:1: ( ( rule__AnnotatedStatement__AnnotationAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11313:1: ( rule__AnnotatedStatement__AnnotationAssignment_1 )

+            {

+             before(grammarAccess.getAnnotatedStatementAccess().getAnnotationAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11314:1: ( rule__AnnotatedStatement__AnnotationAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11314:2: rule__AnnotatedStatement__AnnotationAssignment_1

+            {

+            pushFollow(FOLLOW_rule__AnnotatedStatement__AnnotationAssignment_1_in_rule__AnnotatedStatement__Group__1__Impl23271);

+            rule__AnnotatedStatement__AnnotationAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAnnotatedStatementAccess().getAnnotationAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AnnotatedStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__AnnotatedStatement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11324:1: rule__AnnotatedStatement__Group__2 : rule__AnnotatedStatement__Group__2__Impl ;

+    public final void rule__AnnotatedStatement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11328:1: ( rule__AnnotatedStatement__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11329:2: rule__AnnotatedStatement__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__AnnotatedStatement__Group__2__Impl_in_rule__AnnotatedStatement__Group__223301);

+            rule__AnnotatedStatement__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AnnotatedStatement__Group__2"

+

+

+    // $ANTLR start "rule__AnnotatedStatement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11335:1: rule__AnnotatedStatement__Group__2__Impl : ( ( rule__AnnotatedStatement__StatementAssignment_2 ) ) ;

+    public final void rule__AnnotatedStatement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11339:1: ( ( ( rule__AnnotatedStatement__StatementAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11340:1: ( ( rule__AnnotatedStatement__StatementAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11340:1: ( ( rule__AnnotatedStatement__StatementAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11341:1: ( rule__AnnotatedStatement__StatementAssignment_2 )

+            {

+             before(grammarAccess.getAnnotatedStatementAccess().getStatementAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11342:1: ( rule__AnnotatedStatement__StatementAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11342:2: rule__AnnotatedStatement__StatementAssignment_2

+            {

+            pushFollow(FOLLOW_rule__AnnotatedStatement__StatementAssignment_2_in_rule__AnnotatedStatement__Group__2__Impl23328);

+            rule__AnnotatedStatement__StatementAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAnnotatedStatementAccess().getStatementAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AnnotatedStatement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__Annotation__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11358:1: rule__Annotation__Group__0 : rule__Annotation__Group__0__Impl rule__Annotation__Group__1 ;

+    public final void rule__Annotation__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11362:1: ( rule__Annotation__Group__0__Impl rule__Annotation__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11363:2: rule__Annotation__Group__0__Impl rule__Annotation__Group__1

+            {

+            pushFollow(FOLLOW_rule__Annotation__Group__0__Impl_in_rule__Annotation__Group__023364);

+            rule__Annotation__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Annotation__Group__1_in_rule__Annotation__Group__023367);

+            rule__Annotation__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group__0"

+

+

+    // $ANTLR start "rule__Annotation__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11370:1: rule__Annotation__Group__0__Impl : ( ( rule__Annotation__KindAssignment_0 ) ) ;

+    public final void rule__Annotation__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11374:1: ( ( ( rule__Annotation__KindAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11375:1: ( ( rule__Annotation__KindAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11375:1: ( ( rule__Annotation__KindAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11376:1: ( rule__Annotation__KindAssignment_0 )

+            {

+             before(grammarAccess.getAnnotationAccess().getKindAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11377:1: ( rule__Annotation__KindAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11377:2: rule__Annotation__KindAssignment_0

+            {

+            pushFollow(FOLLOW_rule__Annotation__KindAssignment_0_in_rule__Annotation__Group__0__Impl23394);

+            rule__Annotation__KindAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAnnotationAccess().getKindAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group__0__Impl"

+

+

+    // $ANTLR start "rule__Annotation__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11387:1: rule__Annotation__Group__1 : rule__Annotation__Group__1__Impl ;

+    public final void rule__Annotation__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11391:1: ( rule__Annotation__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11392:2: rule__Annotation__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__Annotation__Group__1__Impl_in_rule__Annotation__Group__123424);

+            rule__Annotation__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group__1"

+

+

+    // $ANTLR start "rule__Annotation__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11398:1: rule__Annotation__Group__1__Impl : ( ( rule__Annotation__Group_1__0 )? ) ;

+    public final void rule__Annotation__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11402:1: ( ( ( rule__Annotation__Group_1__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11403:1: ( ( rule__Annotation__Group_1__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11403:1: ( ( rule__Annotation__Group_1__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11404:1: ( rule__Annotation__Group_1__0 )?

+            {

+             before(grammarAccess.getAnnotationAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11405:1: ( rule__Annotation__Group_1__0 )?

+            int alt86=2;

+            int LA86_0 = input.LA(1);

+

+            if ( (LA86_0==68) ) {

+                alt86=1;

+            }

+            switch (alt86) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11405:2: rule__Annotation__Group_1__0

+                    {

+                    pushFollow(FOLLOW_rule__Annotation__Group_1__0_in_rule__Annotation__Group__1__Impl23451);

+                    rule__Annotation__Group_1__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getAnnotationAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group__1__Impl"

+

+

+    // $ANTLR start "rule__Annotation__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11419:1: rule__Annotation__Group_1__0 : rule__Annotation__Group_1__0__Impl rule__Annotation__Group_1__1 ;

+    public final void rule__Annotation__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11423:1: ( rule__Annotation__Group_1__0__Impl rule__Annotation__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11424:2: rule__Annotation__Group_1__0__Impl rule__Annotation__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__Annotation__Group_1__0__Impl_in_rule__Annotation__Group_1__023486);

+            rule__Annotation__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Annotation__Group_1__1_in_rule__Annotation__Group_1__023489);

+            rule__Annotation__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group_1__0"

+

+

+    // $ANTLR start "rule__Annotation__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11431:1: rule__Annotation__Group_1__0__Impl : ( '(' ) ;

+    public final void rule__Annotation__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11435:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11436:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11436:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11437:1: '('

+            {

+             before(grammarAccess.getAnnotationAccess().getLeftParenthesisKeyword_1_0()); 

+            match(input,68,FOLLOW_68_in_rule__Annotation__Group_1__0__Impl23517); 

+             after(grammarAccess.getAnnotationAccess().getLeftParenthesisKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__Annotation__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11450:1: rule__Annotation__Group_1__1 : rule__Annotation__Group_1__1__Impl rule__Annotation__Group_1__2 ;

+    public final void rule__Annotation__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11454:1: ( rule__Annotation__Group_1__1__Impl rule__Annotation__Group_1__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11455:2: rule__Annotation__Group_1__1__Impl rule__Annotation__Group_1__2

+            {

+            pushFollow(FOLLOW_rule__Annotation__Group_1__1__Impl_in_rule__Annotation__Group_1__123548);

+            rule__Annotation__Group_1__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Annotation__Group_1__2_in_rule__Annotation__Group_1__123551);

+            rule__Annotation__Group_1__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group_1__1"

+

+

+    // $ANTLR start "rule__Annotation__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11462:1: rule__Annotation__Group_1__1__Impl : ( ( rule__Annotation__ArgsAssignment_1_1 ) ) ;

+    public final void rule__Annotation__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11466:1: ( ( ( rule__Annotation__ArgsAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11467:1: ( ( rule__Annotation__ArgsAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11467:1: ( ( rule__Annotation__ArgsAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11468:1: ( rule__Annotation__ArgsAssignment_1_1 )

+            {

+             before(grammarAccess.getAnnotationAccess().getArgsAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11469:1: ( rule__Annotation__ArgsAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11469:2: rule__Annotation__ArgsAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__Annotation__ArgsAssignment_1_1_in_rule__Annotation__Group_1__1__Impl23578);

+            rule__Annotation__ArgsAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAnnotationAccess().getArgsAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__Annotation__Group_1__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11479:1: rule__Annotation__Group_1__2 : rule__Annotation__Group_1__2__Impl rule__Annotation__Group_1__3 ;

+    public final void rule__Annotation__Group_1__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11483:1: ( rule__Annotation__Group_1__2__Impl rule__Annotation__Group_1__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11484:2: rule__Annotation__Group_1__2__Impl rule__Annotation__Group_1__3

+            {

+            pushFollow(FOLLOW_rule__Annotation__Group_1__2__Impl_in_rule__Annotation__Group_1__223608);

+            rule__Annotation__Group_1__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Annotation__Group_1__3_in_rule__Annotation__Group_1__223611);

+            rule__Annotation__Group_1__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group_1__2"

+

+

+    // $ANTLR start "rule__Annotation__Group_1__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11491:1: rule__Annotation__Group_1__2__Impl : ( ( rule__Annotation__Group_1_2__0 )* ) ;

+    public final void rule__Annotation__Group_1__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11495:1: ( ( ( rule__Annotation__Group_1_2__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11496:1: ( ( rule__Annotation__Group_1_2__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11496:1: ( ( rule__Annotation__Group_1_2__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11497:1: ( rule__Annotation__Group_1_2__0 )*

+            {

+             before(grammarAccess.getAnnotationAccess().getGroup_1_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11498:1: ( rule__Annotation__Group_1_2__0 )*

+            loop87:

+            do {

+                int alt87=2;

+                int LA87_0 = input.LA(1);

+

+                if ( (LA87_0==66) ) {

+                    alt87=1;

+                }

+

+

+                switch (alt87) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11498:2: rule__Annotation__Group_1_2__0

+            	    {

+            	    pushFollow(FOLLOW_rule__Annotation__Group_1_2__0_in_rule__Annotation__Group_1__2__Impl23638);

+            	    rule__Annotation__Group_1_2__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop87;

+                }

+            } while (true);

+

+             after(grammarAccess.getAnnotationAccess().getGroup_1_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group_1__2__Impl"

+

+

+    // $ANTLR start "rule__Annotation__Group_1__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11508:1: rule__Annotation__Group_1__3 : rule__Annotation__Group_1__3__Impl ;

+    public final void rule__Annotation__Group_1__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11512:1: ( rule__Annotation__Group_1__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11513:2: rule__Annotation__Group_1__3__Impl

+            {

+            pushFollow(FOLLOW_rule__Annotation__Group_1__3__Impl_in_rule__Annotation__Group_1__323669);

+            rule__Annotation__Group_1__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group_1__3"

+

+

+    // $ANTLR start "rule__Annotation__Group_1__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11519:1: rule__Annotation__Group_1__3__Impl : ( ')' ) ;

+    public final void rule__Annotation__Group_1__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11523:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11524:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11524:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11525:1: ')'

+            {

+             before(grammarAccess.getAnnotationAccess().getRightParenthesisKeyword_1_3()); 

+            match(input,69,FOLLOW_69_in_rule__Annotation__Group_1__3__Impl23697); 

+             after(grammarAccess.getAnnotationAccess().getRightParenthesisKeyword_1_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group_1__3__Impl"

+

+

+    // $ANTLR start "rule__Annotation__Group_1_2__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11546:1: rule__Annotation__Group_1_2__0 : rule__Annotation__Group_1_2__0__Impl rule__Annotation__Group_1_2__1 ;

+    public final void rule__Annotation__Group_1_2__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11550:1: ( rule__Annotation__Group_1_2__0__Impl rule__Annotation__Group_1_2__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11551:2: rule__Annotation__Group_1_2__0__Impl rule__Annotation__Group_1_2__1

+            {

+            pushFollow(FOLLOW_rule__Annotation__Group_1_2__0__Impl_in_rule__Annotation__Group_1_2__023736);

+            rule__Annotation__Group_1_2__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__Annotation__Group_1_2__1_in_rule__Annotation__Group_1_2__023739);

+            rule__Annotation__Group_1_2__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group_1_2__0"

+

+

+    // $ANTLR start "rule__Annotation__Group_1_2__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11558:1: rule__Annotation__Group_1_2__0__Impl : ( ',' ) ;

+    public final void rule__Annotation__Group_1_2__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11562:1: ( ( ',' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11563:1: ( ',' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11563:1: ( ',' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11564:1: ','

+            {

+             before(grammarAccess.getAnnotationAccess().getCommaKeyword_1_2_0()); 

+            match(input,66,FOLLOW_66_in_rule__Annotation__Group_1_2__0__Impl23767); 

+             after(grammarAccess.getAnnotationAccess().getCommaKeyword_1_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group_1_2__0__Impl"

+

+

+    // $ANTLR start "rule__Annotation__Group_1_2__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11577:1: rule__Annotation__Group_1_2__1 : rule__Annotation__Group_1_2__1__Impl ;

+    public final void rule__Annotation__Group_1_2__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11581:1: ( rule__Annotation__Group_1_2__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11582:2: rule__Annotation__Group_1_2__1__Impl

+            {

+            pushFollow(FOLLOW_rule__Annotation__Group_1_2__1__Impl_in_rule__Annotation__Group_1_2__123798);

+            rule__Annotation__Group_1_2__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group_1_2__1"

+

+

+    // $ANTLR start "rule__Annotation__Group_1_2__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11588:1: rule__Annotation__Group_1_2__1__Impl : ( ( rule__Annotation__ArgsAssignment_1_2_1 ) ) ;

+    public final void rule__Annotation__Group_1_2__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11592:1: ( ( ( rule__Annotation__ArgsAssignment_1_2_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11593:1: ( ( rule__Annotation__ArgsAssignment_1_2_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11593:1: ( ( rule__Annotation__ArgsAssignment_1_2_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11594:1: ( rule__Annotation__ArgsAssignment_1_2_1 )

+            {

+             before(grammarAccess.getAnnotationAccess().getArgsAssignment_1_2_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11595:1: ( rule__Annotation__ArgsAssignment_1_2_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11595:2: rule__Annotation__ArgsAssignment_1_2_1

+            {

+            pushFollow(FOLLOW_rule__Annotation__ArgsAssignment_1_2_1_in_rule__Annotation__Group_1_2__1__Impl23825);

+            rule__Annotation__ArgsAssignment_1_2_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAnnotationAccess().getArgsAssignment_1_2_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__Group_1_2__1__Impl"

+

+

+    // $ANTLR start "rule__EmptyStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11609:1: rule__EmptyStatement__Group__0 : rule__EmptyStatement__Group__0__Impl rule__EmptyStatement__Group__1 ;

+    public final void rule__EmptyStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11613:1: ( rule__EmptyStatement__Group__0__Impl rule__EmptyStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11614:2: rule__EmptyStatement__Group__0__Impl rule__EmptyStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__EmptyStatement__Group__0__Impl_in_rule__EmptyStatement__Group__023859);

+            rule__EmptyStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__EmptyStatement__Group__1_in_rule__EmptyStatement__Group__023862);

+            rule__EmptyStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EmptyStatement__Group__0"

+

+

+    // $ANTLR start "rule__EmptyStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11621:1: rule__EmptyStatement__Group__0__Impl : ( () ) ;

+    public final void rule__EmptyStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11625:1: ( ( () ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11626:1: ( () )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11626:1: ( () )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11627:1: ()

+            {

+             before(grammarAccess.getEmptyStatementAccess().getEmptyStatementAction_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11628:1: ()

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11630:1: 

+            {

+            }

+

+             after(grammarAccess.getEmptyStatementAccess().getEmptyStatementAction_0()); 

+

+            }

+

+

+            }

+

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EmptyStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__EmptyStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11640:1: rule__EmptyStatement__Group__1 : rule__EmptyStatement__Group__1__Impl ;

+    public final void rule__EmptyStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11644:1: ( rule__EmptyStatement__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11645:2: rule__EmptyStatement__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__EmptyStatement__Group__1__Impl_in_rule__EmptyStatement__Group__123920);

+            rule__EmptyStatement__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EmptyStatement__Group__1"

+

+

+    // $ANTLR start "rule__EmptyStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11651:1: rule__EmptyStatement__Group__1__Impl : ( ';' ) ;

+    public final void rule__EmptyStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11655:1: ( ( ';' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11656:1: ( ';' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11656:1: ( ';' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11657:1: ';'

+            {

+             before(grammarAccess.getEmptyStatementAccess().getSemicolonKeyword_1()); 

+            match(input,95,FOLLOW_95_in_rule__EmptyStatement__Group__1__Impl23948); 

+             after(grammarAccess.getEmptyStatementAccess().getSemicolonKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EmptyStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11674:1: rule__LocalNameDeclarationStatement__Group__0 : rule__LocalNameDeclarationStatement__Group__0__Impl rule__LocalNameDeclarationStatement__Group__1 ;

+    public final void rule__LocalNameDeclarationStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11678:1: ( rule__LocalNameDeclarationStatement__Group__0__Impl rule__LocalNameDeclarationStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11679:2: rule__LocalNameDeclarationStatement__Group__0__Impl rule__LocalNameDeclarationStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__0__Impl_in_rule__LocalNameDeclarationStatement__Group__023983);

+            rule__LocalNameDeclarationStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__1_in_rule__LocalNameDeclarationStatement__Group__023986);

+            rule__LocalNameDeclarationStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__0"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11686:1: rule__LocalNameDeclarationStatement__Group__0__Impl : ( 'let' ) ;

+    public final void rule__LocalNameDeclarationStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11690:1: ( ( 'let' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11691:1: ( 'let' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11691:1: ( 'let' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11692:1: 'let'

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getLetKeyword_0()); 

+            match(input,96,FOLLOW_96_in_rule__LocalNameDeclarationStatement__Group__0__Impl24014); 

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getLetKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11705:1: rule__LocalNameDeclarationStatement__Group__1 : rule__LocalNameDeclarationStatement__Group__1__Impl rule__LocalNameDeclarationStatement__Group__2 ;

+    public final void rule__LocalNameDeclarationStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11709:1: ( rule__LocalNameDeclarationStatement__Group__1__Impl rule__LocalNameDeclarationStatement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11710:2: rule__LocalNameDeclarationStatement__Group__1__Impl rule__LocalNameDeclarationStatement__Group__2

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__1__Impl_in_rule__LocalNameDeclarationStatement__Group__124045);

+            rule__LocalNameDeclarationStatement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__2_in_rule__LocalNameDeclarationStatement__Group__124048);

+            rule__LocalNameDeclarationStatement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__1"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11717:1: rule__LocalNameDeclarationStatement__Group__1__Impl : ( ( rule__LocalNameDeclarationStatement__VarNameAssignment_1 ) ) ;

+    public final void rule__LocalNameDeclarationStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11721:1: ( ( ( rule__LocalNameDeclarationStatement__VarNameAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11722:1: ( ( rule__LocalNameDeclarationStatement__VarNameAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11722:1: ( ( rule__LocalNameDeclarationStatement__VarNameAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11723:1: ( rule__LocalNameDeclarationStatement__VarNameAssignment_1 )

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11724:1: ( rule__LocalNameDeclarationStatement__VarNameAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11724:2: rule__LocalNameDeclarationStatement__VarNameAssignment_1

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__VarNameAssignment_1_in_rule__LocalNameDeclarationStatement__Group__1__Impl24075);

+            rule__LocalNameDeclarationStatement__VarNameAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11734:1: rule__LocalNameDeclarationStatement__Group__2 : rule__LocalNameDeclarationStatement__Group__2__Impl rule__LocalNameDeclarationStatement__Group__3 ;

+    public final void rule__LocalNameDeclarationStatement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11738:1: ( rule__LocalNameDeclarationStatement__Group__2__Impl rule__LocalNameDeclarationStatement__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11739:2: rule__LocalNameDeclarationStatement__Group__2__Impl rule__LocalNameDeclarationStatement__Group__3

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__2__Impl_in_rule__LocalNameDeclarationStatement__Group__224105);

+            rule__LocalNameDeclarationStatement__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__3_in_rule__LocalNameDeclarationStatement__Group__224108);

+            rule__LocalNameDeclarationStatement__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__2"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11746:1: rule__LocalNameDeclarationStatement__Group__2__Impl : ( ':' ) ;

+    public final void rule__LocalNameDeclarationStatement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11750:1: ( ( ':' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11751:1: ( ':' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11751:1: ( ':' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11752:1: ':'

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getColonKeyword_2()); 

+            match(input,71,FOLLOW_71_in_rule__LocalNameDeclarationStatement__Group__2__Impl24136); 

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getColonKeyword_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11765:1: rule__LocalNameDeclarationStatement__Group__3 : rule__LocalNameDeclarationStatement__Group__3__Impl rule__LocalNameDeclarationStatement__Group__4 ;

+    public final void rule__LocalNameDeclarationStatement__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11769:1: ( rule__LocalNameDeclarationStatement__Group__3__Impl rule__LocalNameDeclarationStatement__Group__4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11770:2: rule__LocalNameDeclarationStatement__Group__3__Impl rule__LocalNameDeclarationStatement__Group__4

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__3__Impl_in_rule__LocalNameDeclarationStatement__Group__324167);

+            rule__LocalNameDeclarationStatement__Group__3__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__4_in_rule__LocalNameDeclarationStatement__Group__324170);

+            rule__LocalNameDeclarationStatement__Group__4();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__3"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11777:1: rule__LocalNameDeclarationStatement__Group__3__Impl : ( ( rule__LocalNameDeclarationStatement__TypeAssignment_3 ) ) ;

+    public final void rule__LocalNameDeclarationStatement__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11781:1: ( ( ( rule__LocalNameDeclarationStatement__TypeAssignment_3 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11782:1: ( ( rule__LocalNameDeclarationStatement__TypeAssignment_3 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11782:1: ( ( rule__LocalNameDeclarationStatement__TypeAssignment_3 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11783:1: ( rule__LocalNameDeclarationStatement__TypeAssignment_3 )

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeAssignment_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11784:1: ( rule__LocalNameDeclarationStatement__TypeAssignment_3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11784:2: rule__LocalNameDeclarationStatement__TypeAssignment_3

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__TypeAssignment_3_in_rule__LocalNameDeclarationStatement__Group__3__Impl24197);

+            rule__LocalNameDeclarationStatement__TypeAssignment_3();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeAssignment_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__3__Impl"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11794:1: rule__LocalNameDeclarationStatement__Group__4 : rule__LocalNameDeclarationStatement__Group__4__Impl rule__LocalNameDeclarationStatement__Group__5 ;

+    public final void rule__LocalNameDeclarationStatement__Group__4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11798:1: ( rule__LocalNameDeclarationStatement__Group__4__Impl rule__LocalNameDeclarationStatement__Group__5 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11799:2: rule__LocalNameDeclarationStatement__Group__4__Impl rule__LocalNameDeclarationStatement__Group__5

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__4__Impl_in_rule__LocalNameDeclarationStatement__Group__424227);

+            rule__LocalNameDeclarationStatement__Group__4__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__5_in_rule__LocalNameDeclarationStatement__Group__424230);

+            rule__LocalNameDeclarationStatement__Group__5();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__4"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__4__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11806:1: rule__LocalNameDeclarationStatement__Group__4__Impl : ( ( rule__LocalNameDeclarationStatement__Group_4__0 )? ) ;

+    public final void rule__LocalNameDeclarationStatement__Group__4__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11810:1: ( ( ( rule__LocalNameDeclarationStatement__Group_4__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11811:1: ( ( rule__LocalNameDeclarationStatement__Group_4__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11811:1: ( ( rule__LocalNameDeclarationStatement__Group_4__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11812:1: ( rule__LocalNameDeclarationStatement__Group_4__0 )?

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup_4()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11813:1: ( rule__LocalNameDeclarationStatement__Group_4__0 )?

+            int alt88=2;

+            int LA88_0 = input.LA(1);

+

+            if ( (LA88_0==78) ) {

+                alt88=1;

+            }

+            switch (alt88) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11813:2: rule__LocalNameDeclarationStatement__Group_4__0

+                    {

+                    pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group_4__0_in_rule__LocalNameDeclarationStatement__Group__4__Impl24257);

+                    rule__LocalNameDeclarationStatement__Group_4__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getGroup_4()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__4__Impl"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__5"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11823:1: rule__LocalNameDeclarationStatement__Group__5 : rule__LocalNameDeclarationStatement__Group__5__Impl rule__LocalNameDeclarationStatement__Group__6 ;

+    public final void rule__LocalNameDeclarationStatement__Group__5() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11827:1: ( rule__LocalNameDeclarationStatement__Group__5__Impl rule__LocalNameDeclarationStatement__Group__6 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11828:2: rule__LocalNameDeclarationStatement__Group__5__Impl rule__LocalNameDeclarationStatement__Group__6

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__5__Impl_in_rule__LocalNameDeclarationStatement__Group__524288);

+            rule__LocalNameDeclarationStatement__Group__5__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__6_in_rule__LocalNameDeclarationStatement__Group__524291);

+            rule__LocalNameDeclarationStatement__Group__6();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__5"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__5__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11835:1: rule__LocalNameDeclarationStatement__Group__5__Impl : ( '=' ) ;

+    public final void rule__LocalNameDeclarationStatement__Group__5__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11839:1: ( ( '=' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11840:1: ( '=' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11840:1: ( '=' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11841:1: '='

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getEqualsSignKeyword_5()); 

+            match(input,49,FOLLOW_49_in_rule__LocalNameDeclarationStatement__Group__5__Impl24319); 

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getEqualsSignKeyword_5()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__5__Impl"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11854:1: rule__LocalNameDeclarationStatement__Group__6 : rule__LocalNameDeclarationStatement__Group__6__Impl rule__LocalNameDeclarationStatement__Group__7 ;

+    public final void rule__LocalNameDeclarationStatement__Group__6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11858:1: ( rule__LocalNameDeclarationStatement__Group__6__Impl rule__LocalNameDeclarationStatement__Group__7 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11859:2: rule__LocalNameDeclarationStatement__Group__6__Impl rule__LocalNameDeclarationStatement__Group__7

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__6__Impl_in_rule__LocalNameDeclarationStatement__Group__624350);

+            rule__LocalNameDeclarationStatement__Group__6__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__7_in_rule__LocalNameDeclarationStatement__Group__624353);

+            rule__LocalNameDeclarationStatement__Group__7();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__6"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__6__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11866:1: rule__LocalNameDeclarationStatement__Group__6__Impl : ( ( rule__LocalNameDeclarationStatement__InitAssignment_6 ) ) ;

+    public final void rule__LocalNameDeclarationStatement__Group__6__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11870:1: ( ( ( rule__LocalNameDeclarationStatement__InitAssignment_6 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11871:1: ( ( rule__LocalNameDeclarationStatement__InitAssignment_6 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11871:1: ( ( rule__LocalNameDeclarationStatement__InitAssignment_6 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11872:1: ( rule__LocalNameDeclarationStatement__InitAssignment_6 )

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getInitAssignment_6()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11873:1: ( rule__LocalNameDeclarationStatement__InitAssignment_6 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11873:2: rule__LocalNameDeclarationStatement__InitAssignment_6

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__InitAssignment_6_in_rule__LocalNameDeclarationStatement__Group__6__Impl24380);

+            rule__LocalNameDeclarationStatement__InitAssignment_6();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getInitAssignment_6()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__6__Impl"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__7"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11883:1: rule__LocalNameDeclarationStatement__Group__7 : rule__LocalNameDeclarationStatement__Group__7__Impl ;

+    public final void rule__LocalNameDeclarationStatement__Group__7() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11887:1: ( rule__LocalNameDeclarationStatement__Group__7__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11888:2: rule__LocalNameDeclarationStatement__Group__7__Impl

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group__7__Impl_in_rule__LocalNameDeclarationStatement__Group__724410);

+            rule__LocalNameDeclarationStatement__Group__7__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__7"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group__7__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11894:1: rule__LocalNameDeclarationStatement__Group__7__Impl : ( ';' ) ;

+    public final void rule__LocalNameDeclarationStatement__Group__7__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11898:1: ( ( ';' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11899:1: ( ';' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11899:1: ( ';' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11900:1: ';'

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getSemicolonKeyword_7()); 

+            match(input,95,FOLLOW_95_in_rule__LocalNameDeclarationStatement__Group__7__Impl24438); 

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getSemicolonKeyword_7()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group__7__Impl"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group_4__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11929:1: rule__LocalNameDeclarationStatement__Group_4__0 : rule__LocalNameDeclarationStatement__Group_4__0__Impl rule__LocalNameDeclarationStatement__Group_4__1 ;

+    public final void rule__LocalNameDeclarationStatement__Group_4__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11933:1: ( rule__LocalNameDeclarationStatement__Group_4__0__Impl rule__LocalNameDeclarationStatement__Group_4__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11934:2: rule__LocalNameDeclarationStatement__Group_4__0__Impl rule__LocalNameDeclarationStatement__Group_4__1

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group_4__0__Impl_in_rule__LocalNameDeclarationStatement__Group_4__024485);

+            rule__LocalNameDeclarationStatement__Group_4__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group_4__1_in_rule__LocalNameDeclarationStatement__Group_4__024488);

+            rule__LocalNameDeclarationStatement__Group_4__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group_4__0"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group_4__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11941:1: rule__LocalNameDeclarationStatement__Group_4__0__Impl : ( ( rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0 ) ) ;

+    public final void rule__LocalNameDeclarationStatement__Group_4__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11945:1: ( ( ( rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11946:1: ( ( rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11946:1: ( ( rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11947:1: ( rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0 )

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorAssignment_4_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11948:1: ( rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11948:2: rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0_in_rule__LocalNameDeclarationStatement__Group_4__0__Impl24515);

+            rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorAssignment_4_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group_4__0__Impl"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group_4__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11958:1: rule__LocalNameDeclarationStatement__Group_4__1 : rule__LocalNameDeclarationStatement__Group_4__1__Impl ;

+    public final void rule__LocalNameDeclarationStatement__Group_4__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11962:1: ( rule__LocalNameDeclarationStatement__Group_4__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11963:2: rule__LocalNameDeclarationStatement__Group_4__1__Impl

+            {

+            pushFollow(FOLLOW_rule__LocalNameDeclarationStatement__Group_4__1__Impl_in_rule__LocalNameDeclarationStatement__Group_4__124545);

+            rule__LocalNameDeclarationStatement__Group_4__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group_4__1"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__Group_4__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11969:1: rule__LocalNameDeclarationStatement__Group_4__1__Impl : ( ']' ) ;

+    public final void rule__LocalNameDeclarationStatement__Group_4__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11973:1: ( ( ']' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11974:1: ( ']' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11974:1: ( ']' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11975:1: ']'

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getRightSquareBracketKeyword_4_1()); 

+            match(input,79,FOLLOW_79_in_rule__LocalNameDeclarationStatement__Group_4__1__Impl24573); 

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getRightSquareBracketKeyword_4_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__Group_4__1__Impl"

+

+

+    // $ANTLR start "rule__IfStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11992:1: rule__IfStatement__Group__0 : rule__IfStatement__Group__0__Impl rule__IfStatement__Group__1 ;

+    public final void rule__IfStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11996:1: ( rule__IfStatement__Group__0__Impl rule__IfStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:11997:2: rule__IfStatement__Group__0__Impl rule__IfStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__IfStatement__Group__0__Impl_in_rule__IfStatement__Group__024608);

+            rule__IfStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__IfStatement__Group__1_in_rule__IfStatement__Group__024611);

+            rule__IfStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IfStatement__Group__0"

+

+

+    // $ANTLR start "rule__IfStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12004:1: rule__IfStatement__Group__0__Impl : ( 'if' ) ;

+    public final void rule__IfStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12008:1: ( ( 'if' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12009:1: ( 'if' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12009:1: ( 'if' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12010:1: 'if'

+            {

+             before(grammarAccess.getIfStatementAccess().getIfKeyword_0()); 

+            match(input,97,FOLLOW_97_in_rule__IfStatement__Group__0__Impl24639); 

+             after(grammarAccess.getIfStatementAccess().getIfKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IfStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__IfStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12023:1: rule__IfStatement__Group__1 : rule__IfStatement__Group__1__Impl rule__IfStatement__Group__2 ;

+    public final void rule__IfStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12027:1: ( rule__IfStatement__Group__1__Impl rule__IfStatement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12028:2: rule__IfStatement__Group__1__Impl rule__IfStatement__Group__2

+            {

+            pushFollow(FOLLOW_rule__IfStatement__Group__1__Impl_in_rule__IfStatement__Group__124670);

+            rule__IfStatement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__IfStatement__Group__2_in_rule__IfStatement__Group__124673);

+            rule__IfStatement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IfStatement__Group__1"

+

+

+    // $ANTLR start "rule__IfStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12035:1: rule__IfStatement__Group__1__Impl : ( ( rule__IfStatement__SequentialClaussesAssignment_1 ) ) ;

+    public final void rule__IfStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12039:1: ( ( ( rule__IfStatement__SequentialClaussesAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12040:1: ( ( rule__IfStatement__SequentialClaussesAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12040:1: ( ( rule__IfStatement__SequentialClaussesAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12041:1: ( rule__IfStatement__SequentialClaussesAssignment_1 )

+            {

+             before(grammarAccess.getIfStatementAccess().getSequentialClaussesAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12042:1: ( rule__IfStatement__SequentialClaussesAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12042:2: rule__IfStatement__SequentialClaussesAssignment_1

+            {

+            pushFollow(FOLLOW_rule__IfStatement__SequentialClaussesAssignment_1_in_rule__IfStatement__Group__1__Impl24700);

+            rule__IfStatement__SequentialClaussesAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getIfStatementAccess().getSequentialClaussesAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IfStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__IfStatement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12052:1: rule__IfStatement__Group__2 : rule__IfStatement__Group__2__Impl ;

+    public final void rule__IfStatement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12056:1: ( rule__IfStatement__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12057:2: rule__IfStatement__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__IfStatement__Group__2__Impl_in_rule__IfStatement__Group__224730);

+            rule__IfStatement__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IfStatement__Group__2"

+

+

+    // $ANTLR start "rule__IfStatement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12063:1: rule__IfStatement__Group__2__Impl : ( ( rule__IfStatement__FinalClauseAssignment_2 )? ) ;

+    public final void rule__IfStatement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12067:1: ( ( ( rule__IfStatement__FinalClauseAssignment_2 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12068:1: ( ( rule__IfStatement__FinalClauseAssignment_2 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12068:1: ( ( rule__IfStatement__FinalClauseAssignment_2 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12069:1: ( rule__IfStatement__FinalClauseAssignment_2 )?

+            {

+             before(grammarAccess.getIfStatementAccess().getFinalClauseAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12070:1: ( rule__IfStatement__FinalClauseAssignment_2 )?

+            int alt89=2;

+            int LA89_0 = input.LA(1);

+

+            if ( (LA89_0==98) ) {

+                alt89=1;

+            }

+            switch (alt89) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12070:2: rule__IfStatement__FinalClauseAssignment_2

+                    {

+                    pushFollow(FOLLOW_rule__IfStatement__FinalClauseAssignment_2_in_rule__IfStatement__Group__2__Impl24757);

+                    rule__IfStatement__FinalClauseAssignment_2();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getIfStatementAccess().getFinalClauseAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IfStatement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__SequentialClauses__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12086:1: rule__SequentialClauses__Group__0 : rule__SequentialClauses__Group__0__Impl rule__SequentialClauses__Group__1 ;

+    public final void rule__SequentialClauses__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12090:1: ( rule__SequentialClauses__Group__0__Impl rule__SequentialClauses__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12091:2: rule__SequentialClauses__Group__0__Impl rule__SequentialClauses__Group__1

+            {

+            pushFollow(FOLLOW_rule__SequentialClauses__Group__0__Impl_in_rule__SequentialClauses__Group__024794);

+            rule__SequentialClauses__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequentialClauses__Group__1_in_rule__SequentialClauses__Group__024797);

+            rule__SequentialClauses__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequentialClauses__Group__0"

+

+

+    // $ANTLR start "rule__SequentialClauses__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12098:1: rule__SequentialClauses__Group__0__Impl : ( ( rule__SequentialClauses__ConccurentClausesAssignment_0 ) ) ;

+    public final void rule__SequentialClauses__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12102:1: ( ( ( rule__SequentialClauses__ConccurentClausesAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12103:1: ( ( rule__SequentialClauses__ConccurentClausesAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12103:1: ( ( rule__SequentialClauses__ConccurentClausesAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12104:1: ( rule__SequentialClauses__ConccurentClausesAssignment_0 )

+            {

+             before(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12105:1: ( rule__SequentialClauses__ConccurentClausesAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12105:2: rule__SequentialClauses__ConccurentClausesAssignment_0

+            {

+            pushFollow(FOLLOW_rule__SequentialClauses__ConccurentClausesAssignment_0_in_rule__SequentialClauses__Group__0__Impl24824);

+            rule__SequentialClauses__ConccurentClausesAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequentialClauses__Group__0__Impl"

+

+

+    // $ANTLR start "rule__SequentialClauses__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12115:1: rule__SequentialClauses__Group__1 : rule__SequentialClauses__Group__1__Impl ;

+    public final void rule__SequentialClauses__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12119:1: ( rule__SequentialClauses__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12120:2: rule__SequentialClauses__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__SequentialClauses__Group__1__Impl_in_rule__SequentialClauses__Group__124854);

+            rule__SequentialClauses__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequentialClauses__Group__1"

+

+

+    // $ANTLR start "rule__SequentialClauses__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12126:1: rule__SequentialClauses__Group__1__Impl : ( ( rule__SequentialClauses__Group_1__0 )* ) ;

+    public final void rule__SequentialClauses__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12130:1: ( ( ( rule__SequentialClauses__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12131:1: ( ( rule__SequentialClauses__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12131:1: ( ( rule__SequentialClauses__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12132:1: ( rule__SequentialClauses__Group_1__0 )*

+            {

+             before(grammarAccess.getSequentialClausesAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12133:1: ( rule__SequentialClauses__Group_1__0 )*

+            loop90:

+            do {

+                int alt90=2;

+                int LA90_0 = input.LA(1);

+

+                if ( (LA90_0==98) ) {

+                    int LA90_2 = input.LA(2);

+

+                    if ( (LA90_2==97) ) {

+                        alt90=1;

+                    }

+

+

+                }

+

+

+                switch (alt90) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12133:2: rule__SequentialClauses__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__SequentialClauses__Group_1__0_in_rule__SequentialClauses__Group__1__Impl24881);

+            	    rule__SequentialClauses__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop90;

+                }

+            } while (true);

+

+             after(grammarAccess.getSequentialClausesAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequentialClauses__Group__1__Impl"

+

+

+    // $ANTLR start "rule__SequentialClauses__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12147:1: rule__SequentialClauses__Group_1__0 : rule__SequentialClauses__Group_1__0__Impl rule__SequentialClauses__Group_1__1 ;

+    public final void rule__SequentialClauses__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12151:1: ( rule__SequentialClauses__Group_1__0__Impl rule__SequentialClauses__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12152:2: rule__SequentialClauses__Group_1__0__Impl rule__SequentialClauses__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__SequentialClauses__Group_1__0__Impl_in_rule__SequentialClauses__Group_1__024916);

+            rule__SequentialClauses__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequentialClauses__Group_1__1_in_rule__SequentialClauses__Group_1__024919);

+            rule__SequentialClauses__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequentialClauses__Group_1__0"

+

+

+    // $ANTLR start "rule__SequentialClauses__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12159:1: rule__SequentialClauses__Group_1__0__Impl : ( 'else' ) ;

+    public final void rule__SequentialClauses__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12163:1: ( ( 'else' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12164:1: ( 'else' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12164:1: ( 'else' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12165:1: 'else'

+            {

+             before(grammarAccess.getSequentialClausesAccess().getElseKeyword_1_0()); 

+            match(input,98,FOLLOW_98_in_rule__SequentialClauses__Group_1__0__Impl24947); 

+             after(grammarAccess.getSequentialClausesAccess().getElseKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequentialClauses__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__SequentialClauses__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12178:1: rule__SequentialClauses__Group_1__1 : rule__SequentialClauses__Group_1__1__Impl rule__SequentialClauses__Group_1__2 ;

+    public final void rule__SequentialClauses__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12182:1: ( rule__SequentialClauses__Group_1__1__Impl rule__SequentialClauses__Group_1__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12183:2: rule__SequentialClauses__Group_1__1__Impl rule__SequentialClauses__Group_1__2

+            {

+            pushFollow(FOLLOW_rule__SequentialClauses__Group_1__1__Impl_in_rule__SequentialClauses__Group_1__124978);

+            rule__SequentialClauses__Group_1__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SequentialClauses__Group_1__2_in_rule__SequentialClauses__Group_1__124981);

+            rule__SequentialClauses__Group_1__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequentialClauses__Group_1__1"

+

+

+    // $ANTLR start "rule__SequentialClauses__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12190:1: rule__SequentialClauses__Group_1__1__Impl : ( 'if' ) ;

+    public final void rule__SequentialClauses__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12194:1: ( ( 'if' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12195:1: ( 'if' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12195:1: ( 'if' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12196:1: 'if'

+            {

+             before(grammarAccess.getSequentialClausesAccess().getIfKeyword_1_1()); 

+            match(input,97,FOLLOW_97_in_rule__SequentialClauses__Group_1__1__Impl25009); 

+             after(grammarAccess.getSequentialClausesAccess().getIfKeyword_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequentialClauses__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__SequentialClauses__Group_1__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12209:1: rule__SequentialClauses__Group_1__2 : rule__SequentialClauses__Group_1__2__Impl ;

+    public final void rule__SequentialClauses__Group_1__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12213:1: ( rule__SequentialClauses__Group_1__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12214:2: rule__SequentialClauses__Group_1__2__Impl

+            {

+            pushFollow(FOLLOW_rule__SequentialClauses__Group_1__2__Impl_in_rule__SequentialClauses__Group_1__225040);

+            rule__SequentialClauses__Group_1__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequentialClauses__Group_1__2"

+

+

+    // $ANTLR start "rule__SequentialClauses__Group_1__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12220:1: rule__SequentialClauses__Group_1__2__Impl : ( ( rule__SequentialClauses__ConccurentClausesAssignment_1_2 ) ) ;

+    public final void rule__SequentialClauses__Group_1__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12224:1: ( ( ( rule__SequentialClauses__ConccurentClausesAssignment_1_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12225:1: ( ( rule__SequentialClauses__ConccurentClausesAssignment_1_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12225:1: ( ( rule__SequentialClauses__ConccurentClausesAssignment_1_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12226:1: ( rule__SequentialClauses__ConccurentClausesAssignment_1_2 )

+            {

+             before(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_1_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12227:1: ( rule__SequentialClauses__ConccurentClausesAssignment_1_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12227:2: rule__SequentialClauses__ConccurentClausesAssignment_1_2

+            {

+            pushFollow(FOLLOW_rule__SequentialClauses__ConccurentClausesAssignment_1_2_in_rule__SequentialClauses__Group_1__2__Impl25067);

+            rule__SequentialClauses__ConccurentClausesAssignment_1_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSequentialClausesAccess().getConccurentClausesAssignment_1_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequentialClauses__Group_1__2__Impl"

+

+

+    // $ANTLR start "rule__ConcurrentClauses__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12243:1: rule__ConcurrentClauses__Group__0 : rule__ConcurrentClauses__Group__0__Impl rule__ConcurrentClauses__Group__1 ;

+    public final void rule__ConcurrentClauses__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12247:1: ( rule__ConcurrentClauses__Group__0__Impl rule__ConcurrentClauses__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12248:2: rule__ConcurrentClauses__Group__0__Impl rule__ConcurrentClauses__Group__1

+            {

+            pushFollow(FOLLOW_rule__ConcurrentClauses__Group__0__Impl_in_rule__ConcurrentClauses__Group__025103);

+            rule__ConcurrentClauses__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ConcurrentClauses__Group__1_in_rule__ConcurrentClauses__Group__025106);

+            rule__ConcurrentClauses__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConcurrentClauses__Group__0"

+

+

+    // $ANTLR start "rule__ConcurrentClauses__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12255:1: rule__ConcurrentClauses__Group__0__Impl : ( ( rule__ConcurrentClauses__NonFinalClauseAssignment_0 ) ) ;

+    public final void rule__ConcurrentClauses__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12259:1: ( ( ( rule__ConcurrentClauses__NonFinalClauseAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12260:1: ( ( rule__ConcurrentClauses__NonFinalClauseAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12260:1: ( ( rule__ConcurrentClauses__NonFinalClauseAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12261:1: ( rule__ConcurrentClauses__NonFinalClauseAssignment_0 )

+            {

+             before(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12262:1: ( rule__ConcurrentClauses__NonFinalClauseAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12262:2: rule__ConcurrentClauses__NonFinalClauseAssignment_0

+            {

+            pushFollow(FOLLOW_rule__ConcurrentClauses__NonFinalClauseAssignment_0_in_rule__ConcurrentClauses__Group__0__Impl25133);

+            rule__ConcurrentClauses__NonFinalClauseAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConcurrentClauses__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ConcurrentClauses__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12272:1: rule__ConcurrentClauses__Group__1 : rule__ConcurrentClauses__Group__1__Impl ;

+    public final void rule__ConcurrentClauses__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12276:1: ( rule__ConcurrentClauses__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12277:2: rule__ConcurrentClauses__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ConcurrentClauses__Group__1__Impl_in_rule__ConcurrentClauses__Group__125163);

+            rule__ConcurrentClauses__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConcurrentClauses__Group__1"

+

+

+    // $ANTLR start "rule__ConcurrentClauses__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12283:1: rule__ConcurrentClauses__Group__1__Impl : ( ( rule__ConcurrentClauses__Group_1__0 )* ) ;

+    public final void rule__ConcurrentClauses__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12287:1: ( ( ( rule__ConcurrentClauses__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12288:1: ( ( rule__ConcurrentClauses__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12288:1: ( ( rule__ConcurrentClauses__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12289:1: ( rule__ConcurrentClauses__Group_1__0 )*

+            {

+             before(grammarAccess.getConcurrentClausesAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12290:1: ( rule__ConcurrentClauses__Group_1__0 )*

+            loop91:

+            do {

+                int alt91=2;

+                int LA91_0 = input.LA(1);

+

+                if ( (LA91_0==99) ) {

+                    alt91=1;

+                }

+

+

+                switch (alt91) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12290:2: rule__ConcurrentClauses__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__ConcurrentClauses__Group_1__0_in_rule__ConcurrentClauses__Group__1__Impl25190);

+            	    rule__ConcurrentClauses__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop91;

+                }

+            } while (true);

+

+             after(grammarAccess.getConcurrentClausesAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConcurrentClauses__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ConcurrentClauses__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12304:1: rule__ConcurrentClauses__Group_1__0 : rule__ConcurrentClauses__Group_1__0__Impl rule__ConcurrentClauses__Group_1__1 ;

+    public final void rule__ConcurrentClauses__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12308:1: ( rule__ConcurrentClauses__Group_1__0__Impl rule__ConcurrentClauses__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12309:2: rule__ConcurrentClauses__Group_1__0__Impl rule__ConcurrentClauses__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__ConcurrentClauses__Group_1__0__Impl_in_rule__ConcurrentClauses__Group_1__025225);

+            rule__ConcurrentClauses__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ConcurrentClauses__Group_1__1_in_rule__ConcurrentClauses__Group_1__025228);

+            rule__ConcurrentClauses__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConcurrentClauses__Group_1__0"

+

+

+    // $ANTLR start "rule__ConcurrentClauses__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12316:1: rule__ConcurrentClauses__Group_1__0__Impl : ( 'or' ) ;

+    public final void rule__ConcurrentClauses__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12320:1: ( ( 'or' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12321:1: ( 'or' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12321:1: ( 'or' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12322:1: 'or'

+            {

+             before(grammarAccess.getConcurrentClausesAccess().getOrKeyword_1_0()); 

+            match(input,99,FOLLOW_99_in_rule__ConcurrentClauses__Group_1__0__Impl25256); 

+             after(grammarAccess.getConcurrentClausesAccess().getOrKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConcurrentClauses__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__ConcurrentClauses__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12335:1: rule__ConcurrentClauses__Group_1__1 : rule__ConcurrentClauses__Group_1__1__Impl rule__ConcurrentClauses__Group_1__2 ;

+    public final void rule__ConcurrentClauses__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12339:1: ( rule__ConcurrentClauses__Group_1__1__Impl rule__ConcurrentClauses__Group_1__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12340:2: rule__ConcurrentClauses__Group_1__1__Impl rule__ConcurrentClauses__Group_1__2

+            {

+            pushFollow(FOLLOW_rule__ConcurrentClauses__Group_1__1__Impl_in_rule__ConcurrentClauses__Group_1__125287);

+            rule__ConcurrentClauses__Group_1__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ConcurrentClauses__Group_1__2_in_rule__ConcurrentClauses__Group_1__125290);

+            rule__ConcurrentClauses__Group_1__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConcurrentClauses__Group_1__1"

+

+

+    // $ANTLR start "rule__ConcurrentClauses__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12347:1: rule__ConcurrentClauses__Group_1__1__Impl : ( 'if' ) ;

+    public final void rule__ConcurrentClauses__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12351:1: ( ( 'if' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12352:1: ( 'if' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12352:1: ( 'if' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12353:1: 'if'

+            {

+             before(grammarAccess.getConcurrentClausesAccess().getIfKeyword_1_1()); 

+            match(input,97,FOLLOW_97_in_rule__ConcurrentClauses__Group_1__1__Impl25318); 

+             after(grammarAccess.getConcurrentClausesAccess().getIfKeyword_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConcurrentClauses__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__ConcurrentClauses__Group_1__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12366:1: rule__ConcurrentClauses__Group_1__2 : rule__ConcurrentClauses__Group_1__2__Impl ;

+    public final void rule__ConcurrentClauses__Group_1__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12370:1: ( rule__ConcurrentClauses__Group_1__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12371:2: rule__ConcurrentClauses__Group_1__2__Impl

+            {

+            pushFollow(FOLLOW_rule__ConcurrentClauses__Group_1__2__Impl_in_rule__ConcurrentClauses__Group_1__225349);

+            rule__ConcurrentClauses__Group_1__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConcurrentClauses__Group_1__2"

+

+

+    // $ANTLR start "rule__ConcurrentClauses__Group_1__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12377:1: rule__ConcurrentClauses__Group_1__2__Impl : ( ( rule__ConcurrentClauses__NonFinalClauseAssignment_1_2 ) ) ;

+    public final void rule__ConcurrentClauses__Group_1__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12381:1: ( ( ( rule__ConcurrentClauses__NonFinalClauseAssignment_1_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12382:1: ( ( rule__ConcurrentClauses__NonFinalClauseAssignment_1_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12382:1: ( ( rule__ConcurrentClauses__NonFinalClauseAssignment_1_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12383:1: ( rule__ConcurrentClauses__NonFinalClauseAssignment_1_2 )

+            {

+             before(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_1_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12384:1: ( rule__ConcurrentClauses__NonFinalClauseAssignment_1_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12384:2: rule__ConcurrentClauses__NonFinalClauseAssignment_1_2

+            {

+            pushFollow(FOLLOW_rule__ConcurrentClauses__NonFinalClauseAssignment_1_2_in_rule__ConcurrentClauses__Group_1__2__Impl25376);

+            rule__ConcurrentClauses__NonFinalClauseAssignment_1_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseAssignment_1_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConcurrentClauses__Group_1__2__Impl"

+

+

+    // $ANTLR start "rule__NonFinalClause__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12400:1: rule__NonFinalClause__Group__0 : rule__NonFinalClause__Group__0__Impl rule__NonFinalClause__Group__1 ;

+    public final void rule__NonFinalClause__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12404:1: ( rule__NonFinalClause__Group__0__Impl rule__NonFinalClause__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12405:2: rule__NonFinalClause__Group__0__Impl rule__NonFinalClause__Group__1

+            {

+            pushFollow(FOLLOW_rule__NonFinalClause__Group__0__Impl_in_rule__NonFinalClause__Group__025412);

+            rule__NonFinalClause__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__NonFinalClause__Group__1_in_rule__NonFinalClause__Group__025415);

+            rule__NonFinalClause__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NonFinalClause__Group__0"

+

+

+    // $ANTLR start "rule__NonFinalClause__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12412:1: rule__NonFinalClause__Group__0__Impl : ( '(' ) ;

+    public final void rule__NonFinalClause__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12416:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12417:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12417:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12418:1: '('

+            {

+             before(grammarAccess.getNonFinalClauseAccess().getLeftParenthesisKeyword_0()); 

+            match(input,68,FOLLOW_68_in_rule__NonFinalClause__Group__0__Impl25443); 

+             after(grammarAccess.getNonFinalClauseAccess().getLeftParenthesisKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NonFinalClause__Group__0__Impl"

+

+

+    // $ANTLR start "rule__NonFinalClause__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12431:1: rule__NonFinalClause__Group__1 : rule__NonFinalClause__Group__1__Impl rule__NonFinalClause__Group__2 ;

+    public final void rule__NonFinalClause__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12435:1: ( rule__NonFinalClause__Group__1__Impl rule__NonFinalClause__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12436:2: rule__NonFinalClause__Group__1__Impl rule__NonFinalClause__Group__2

+            {

+            pushFollow(FOLLOW_rule__NonFinalClause__Group__1__Impl_in_rule__NonFinalClause__Group__125474);

+            rule__NonFinalClause__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__NonFinalClause__Group__2_in_rule__NonFinalClause__Group__125477);

+            rule__NonFinalClause__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NonFinalClause__Group__1"

+

+

+    // $ANTLR start "rule__NonFinalClause__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12443:1: rule__NonFinalClause__Group__1__Impl : ( ( rule__NonFinalClause__ConditionAssignment_1 ) ) ;

+    public final void rule__NonFinalClause__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12447:1: ( ( ( rule__NonFinalClause__ConditionAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12448:1: ( ( rule__NonFinalClause__ConditionAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12448:1: ( ( rule__NonFinalClause__ConditionAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12449:1: ( rule__NonFinalClause__ConditionAssignment_1 )

+            {

+             before(grammarAccess.getNonFinalClauseAccess().getConditionAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12450:1: ( rule__NonFinalClause__ConditionAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12450:2: rule__NonFinalClause__ConditionAssignment_1

+            {

+            pushFollow(FOLLOW_rule__NonFinalClause__ConditionAssignment_1_in_rule__NonFinalClause__Group__1__Impl25504);

+            rule__NonFinalClause__ConditionAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNonFinalClauseAccess().getConditionAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NonFinalClause__Group__1__Impl"

+

+

+    // $ANTLR start "rule__NonFinalClause__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12460:1: rule__NonFinalClause__Group__2 : rule__NonFinalClause__Group__2__Impl rule__NonFinalClause__Group__3 ;

+    public final void rule__NonFinalClause__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12464:1: ( rule__NonFinalClause__Group__2__Impl rule__NonFinalClause__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12465:2: rule__NonFinalClause__Group__2__Impl rule__NonFinalClause__Group__3

+            {

+            pushFollow(FOLLOW_rule__NonFinalClause__Group__2__Impl_in_rule__NonFinalClause__Group__225534);

+            rule__NonFinalClause__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__NonFinalClause__Group__3_in_rule__NonFinalClause__Group__225537);

+            rule__NonFinalClause__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NonFinalClause__Group__2"

+

+

+    // $ANTLR start "rule__NonFinalClause__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12472:1: rule__NonFinalClause__Group__2__Impl : ( ')' ) ;

+    public final void rule__NonFinalClause__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12476:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12477:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12477:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12478:1: ')'

+            {

+             before(grammarAccess.getNonFinalClauseAccess().getRightParenthesisKeyword_2()); 

+            match(input,69,FOLLOW_69_in_rule__NonFinalClause__Group__2__Impl25565); 

+             after(grammarAccess.getNonFinalClauseAccess().getRightParenthesisKeyword_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NonFinalClause__Group__2__Impl"

+

+

+    // $ANTLR start "rule__NonFinalClause__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12491:1: rule__NonFinalClause__Group__3 : rule__NonFinalClause__Group__3__Impl ;

+    public final void rule__NonFinalClause__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12495:1: ( rule__NonFinalClause__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12496:2: rule__NonFinalClause__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__NonFinalClause__Group__3__Impl_in_rule__NonFinalClause__Group__325596);

+            rule__NonFinalClause__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NonFinalClause__Group__3"

+

+

+    // $ANTLR start "rule__NonFinalClause__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12502:1: rule__NonFinalClause__Group__3__Impl : ( ( rule__NonFinalClause__BlockAssignment_3 ) ) ;

+    public final void rule__NonFinalClause__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12506:1: ( ( ( rule__NonFinalClause__BlockAssignment_3 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12507:1: ( ( rule__NonFinalClause__BlockAssignment_3 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12507:1: ( ( rule__NonFinalClause__BlockAssignment_3 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12508:1: ( rule__NonFinalClause__BlockAssignment_3 )

+            {

+             before(grammarAccess.getNonFinalClauseAccess().getBlockAssignment_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12509:1: ( rule__NonFinalClause__BlockAssignment_3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12509:2: rule__NonFinalClause__BlockAssignment_3

+            {

+            pushFollow(FOLLOW_rule__NonFinalClause__BlockAssignment_3_in_rule__NonFinalClause__Group__3__Impl25623);

+            rule__NonFinalClause__BlockAssignment_3();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNonFinalClauseAccess().getBlockAssignment_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NonFinalClause__Group__3__Impl"

+

+

+    // $ANTLR start "rule__FinalClause__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12527:1: rule__FinalClause__Group__0 : rule__FinalClause__Group__0__Impl rule__FinalClause__Group__1 ;

+    public final void rule__FinalClause__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12531:1: ( rule__FinalClause__Group__0__Impl rule__FinalClause__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12532:2: rule__FinalClause__Group__0__Impl rule__FinalClause__Group__1

+            {

+            pushFollow(FOLLOW_rule__FinalClause__Group__0__Impl_in_rule__FinalClause__Group__025661);

+            rule__FinalClause__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__FinalClause__Group__1_in_rule__FinalClause__Group__025664);

+            rule__FinalClause__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__FinalClause__Group__0"

+

+

+    // $ANTLR start "rule__FinalClause__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12539:1: rule__FinalClause__Group__0__Impl : ( 'else' ) ;

+    public final void rule__FinalClause__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12543:1: ( ( 'else' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12544:1: ( 'else' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12544:1: ( 'else' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12545:1: 'else'

+            {

+             before(grammarAccess.getFinalClauseAccess().getElseKeyword_0()); 

+            match(input,98,FOLLOW_98_in_rule__FinalClause__Group__0__Impl25692); 

+             after(grammarAccess.getFinalClauseAccess().getElseKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__FinalClause__Group__0__Impl"

+

+

+    // $ANTLR start "rule__FinalClause__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12558:1: rule__FinalClause__Group__1 : rule__FinalClause__Group__1__Impl ;

+    public final void rule__FinalClause__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12562:1: ( rule__FinalClause__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12563:2: rule__FinalClause__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__FinalClause__Group__1__Impl_in_rule__FinalClause__Group__125723);

+            rule__FinalClause__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__FinalClause__Group__1"

+

+

+    // $ANTLR start "rule__FinalClause__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12569:1: rule__FinalClause__Group__1__Impl : ( ( rule__FinalClause__BlockAssignment_1 ) ) ;

+    public final void rule__FinalClause__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12573:1: ( ( ( rule__FinalClause__BlockAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12574:1: ( ( rule__FinalClause__BlockAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12574:1: ( ( rule__FinalClause__BlockAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12575:1: ( rule__FinalClause__BlockAssignment_1 )

+            {

+             before(grammarAccess.getFinalClauseAccess().getBlockAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12576:1: ( rule__FinalClause__BlockAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12576:2: rule__FinalClause__BlockAssignment_1

+            {

+            pushFollow(FOLLOW_rule__FinalClause__BlockAssignment_1_in_rule__FinalClause__Group__1__Impl25750);

+            rule__FinalClause__BlockAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getFinalClauseAccess().getBlockAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__FinalClause__Group__1__Impl"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12590:1: rule__SwitchStatement__Group__0 : rule__SwitchStatement__Group__0__Impl rule__SwitchStatement__Group__1 ;

+    public final void rule__SwitchStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12594:1: ( rule__SwitchStatement__Group__0__Impl rule__SwitchStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12595:2: rule__SwitchStatement__Group__0__Impl rule__SwitchStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__0__Impl_in_rule__SwitchStatement__Group__025784);

+            rule__SwitchStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__1_in_rule__SwitchStatement__Group__025787);

+            rule__SwitchStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__0"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12602:1: rule__SwitchStatement__Group__0__Impl : ( 'switch' ) ;

+    public final void rule__SwitchStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12606:1: ( ( 'switch' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12607:1: ( 'switch' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12607:1: ( 'switch' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12608:1: 'switch'

+            {

+             before(grammarAccess.getSwitchStatementAccess().getSwitchKeyword_0()); 

+            match(input,100,FOLLOW_100_in_rule__SwitchStatement__Group__0__Impl25815); 

+             after(grammarAccess.getSwitchStatementAccess().getSwitchKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12621:1: rule__SwitchStatement__Group__1 : rule__SwitchStatement__Group__1__Impl rule__SwitchStatement__Group__2 ;

+    public final void rule__SwitchStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12625:1: ( rule__SwitchStatement__Group__1__Impl rule__SwitchStatement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12626:2: rule__SwitchStatement__Group__1__Impl rule__SwitchStatement__Group__2

+            {

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__1__Impl_in_rule__SwitchStatement__Group__125846);

+            rule__SwitchStatement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__2_in_rule__SwitchStatement__Group__125849);

+            rule__SwitchStatement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__1"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12633:1: rule__SwitchStatement__Group__1__Impl : ( '(' ) ;

+    public final void rule__SwitchStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12637:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12638:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12638:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12639:1: '('

+            {

+             before(grammarAccess.getSwitchStatementAccess().getLeftParenthesisKeyword_1()); 

+            match(input,68,FOLLOW_68_in_rule__SwitchStatement__Group__1__Impl25877); 

+             after(grammarAccess.getSwitchStatementAccess().getLeftParenthesisKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12652:1: rule__SwitchStatement__Group__2 : rule__SwitchStatement__Group__2__Impl rule__SwitchStatement__Group__3 ;

+    public final void rule__SwitchStatement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12656:1: ( rule__SwitchStatement__Group__2__Impl rule__SwitchStatement__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12657:2: rule__SwitchStatement__Group__2__Impl rule__SwitchStatement__Group__3

+            {

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__2__Impl_in_rule__SwitchStatement__Group__225908);

+            rule__SwitchStatement__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__3_in_rule__SwitchStatement__Group__225911);

+            rule__SwitchStatement__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__2"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12664:1: rule__SwitchStatement__Group__2__Impl : ( ( rule__SwitchStatement__ExpressionAssignment_2 ) ) ;

+    public final void rule__SwitchStatement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12668:1: ( ( ( rule__SwitchStatement__ExpressionAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12669:1: ( ( rule__SwitchStatement__ExpressionAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12669:1: ( ( rule__SwitchStatement__ExpressionAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12670:1: ( rule__SwitchStatement__ExpressionAssignment_2 )

+            {

+             before(grammarAccess.getSwitchStatementAccess().getExpressionAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12671:1: ( rule__SwitchStatement__ExpressionAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12671:2: rule__SwitchStatement__ExpressionAssignment_2

+            {

+            pushFollow(FOLLOW_rule__SwitchStatement__ExpressionAssignment_2_in_rule__SwitchStatement__Group__2__Impl25938);

+            rule__SwitchStatement__ExpressionAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSwitchStatementAccess().getExpressionAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12681:1: rule__SwitchStatement__Group__3 : rule__SwitchStatement__Group__3__Impl rule__SwitchStatement__Group__4 ;

+    public final void rule__SwitchStatement__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12685:1: ( rule__SwitchStatement__Group__3__Impl rule__SwitchStatement__Group__4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12686:2: rule__SwitchStatement__Group__3__Impl rule__SwitchStatement__Group__4

+            {

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__3__Impl_in_rule__SwitchStatement__Group__325968);

+            rule__SwitchStatement__Group__3__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__4_in_rule__SwitchStatement__Group__325971);

+            rule__SwitchStatement__Group__4();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__3"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12693:1: rule__SwitchStatement__Group__3__Impl : ( ')' ) ;

+    public final void rule__SwitchStatement__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12697:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12698:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12698:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12699:1: ')'

+            {

+             before(grammarAccess.getSwitchStatementAccess().getRightParenthesisKeyword_3()); 

+            match(input,69,FOLLOW_69_in_rule__SwitchStatement__Group__3__Impl25999); 

+             after(grammarAccess.getSwitchStatementAccess().getRightParenthesisKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__3__Impl"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12712:1: rule__SwitchStatement__Group__4 : rule__SwitchStatement__Group__4__Impl rule__SwitchStatement__Group__5 ;

+    public final void rule__SwitchStatement__Group__4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12716:1: ( rule__SwitchStatement__Group__4__Impl rule__SwitchStatement__Group__5 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12717:2: rule__SwitchStatement__Group__4__Impl rule__SwitchStatement__Group__5

+            {

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__4__Impl_in_rule__SwitchStatement__Group__426030);

+            rule__SwitchStatement__Group__4__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__5_in_rule__SwitchStatement__Group__426033);

+            rule__SwitchStatement__Group__5();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__4"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__4__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12724:1: rule__SwitchStatement__Group__4__Impl : ( '{' ) ;

+    public final void rule__SwitchStatement__Group__4__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12728:1: ( ( '{' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12729:1: ( '{' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12729:1: ( '{' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12730:1: '{'

+            {

+             before(grammarAccess.getSwitchStatementAccess().getLeftCurlyBracketKeyword_4()); 

+            match(input,87,FOLLOW_87_in_rule__SwitchStatement__Group__4__Impl26061); 

+             after(grammarAccess.getSwitchStatementAccess().getLeftCurlyBracketKeyword_4()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__4__Impl"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__5"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12743:1: rule__SwitchStatement__Group__5 : rule__SwitchStatement__Group__5__Impl rule__SwitchStatement__Group__6 ;

+    public final void rule__SwitchStatement__Group__5() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12747:1: ( rule__SwitchStatement__Group__5__Impl rule__SwitchStatement__Group__6 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12748:2: rule__SwitchStatement__Group__5__Impl rule__SwitchStatement__Group__6

+            {

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__5__Impl_in_rule__SwitchStatement__Group__526092);

+            rule__SwitchStatement__Group__5__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__6_in_rule__SwitchStatement__Group__526095);

+            rule__SwitchStatement__Group__6();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__5"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__5__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12755:1: rule__SwitchStatement__Group__5__Impl : ( ( rule__SwitchStatement__SwitchClauseAssignment_5 )* ) ;

+    public final void rule__SwitchStatement__Group__5__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12759:1: ( ( ( rule__SwitchStatement__SwitchClauseAssignment_5 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12760:1: ( ( rule__SwitchStatement__SwitchClauseAssignment_5 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12760:1: ( ( rule__SwitchStatement__SwitchClauseAssignment_5 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12761:1: ( rule__SwitchStatement__SwitchClauseAssignment_5 )*

+            {

+             before(grammarAccess.getSwitchStatementAccess().getSwitchClauseAssignment_5()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12762:1: ( rule__SwitchStatement__SwitchClauseAssignment_5 )*

+            loop92:

+            do {

+                int alt92=2;

+                int LA92_0 = input.LA(1);

+

+                if ( (LA92_0==101) ) {

+                    alt92=1;

+                }

+

+

+                switch (alt92) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12762:2: rule__SwitchStatement__SwitchClauseAssignment_5

+            	    {

+            	    pushFollow(FOLLOW_rule__SwitchStatement__SwitchClauseAssignment_5_in_rule__SwitchStatement__Group__5__Impl26122);

+            	    rule__SwitchStatement__SwitchClauseAssignment_5();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop92;

+                }

+            } while (true);

+

+             after(grammarAccess.getSwitchStatementAccess().getSwitchClauseAssignment_5()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__5__Impl"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12772:1: rule__SwitchStatement__Group__6 : rule__SwitchStatement__Group__6__Impl rule__SwitchStatement__Group__7 ;

+    public final void rule__SwitchStatement__Group__6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12776:1: ( rule__SwitchStatement__Group__6__Impl rule__SwitchStatement__Group__7 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12777:2: rule__SwitchStatement__Group__6__Impl rule__SwitchStatement__Group__7

+            {

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__6__Impl_in_rule__SwitchStatement__Group__626153);

+            rule__SwitchStatement__Group__6__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__7_in_rule__SwitchStatement__Group__626156);

+            rule__SwitchStatement__Group__7();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__6"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__6__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12784:1: rule__SwitchStatement__Group__6__Impl : ( ( rule__SwitchStatement__DefaultClauseAssignment_6 )? ) ;

+    public final void rule__SwitchStatement__Group__6__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12788:1: ( ( ( rule__SwitchStatement__DefaultClauseAssignment_6 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12789:1: ( ( rule__SwitchStatement__DefaultClauseAssignment_6 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12789:1: ( ( rule__SwitchStatement__DefaultClauseAssignment_6 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12790:1: ( rule__SwitchStatement__DefaultClauseAssignment_6 )?

+            {

+             before(grammarAccess.getSwitchStatementAccess().getDefaultClauseAssignment_6()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12791:1: ( rule__SwitchStatement__DefaultClauseAssignment_6 )?

+            int alt93=2;

+            int LA93_0 = input.LA(1);

+

+            if ( (LA93_0==102) ) {

+                alt93=1;

+            }

+            switch (alt93) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12791:2: rule__SwitchStatement__DefaultClauseAssignment_6

+                    {

+                    pushFollow(FOLLOW_rule__SwitchStatement__DefaultClauseAssignment_6_in_rule__SwitchStatement__Group__6__Impl26183);

+                    rule__SwitchStatement__DefaultClauseAssignment_6();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getSwitchStatementAccess().getDefaultClauseAssignment_6()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__6__Impl"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__7"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12801:1: rule__SwitchStatement__Group__7 : rule__SwitchStatement__Group__7__Impl ;

+    public final void rule__SwitchStatement__Group__7() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12805:1: ( rule__SwitchStatement__Group__7__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12806:2: rule__SwitchStatement__Group__7__Impl

+            {

+            pushFollow(FOLLOW_rule__SwitchStatement__Group__7__Impl_in_rule__SwitchStatement__Group__726214);

+            rule__SwitchStatement__Group__7__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__7"

+

+

+    // $ANTLR start "rule__SwitchStatement__Group__7__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12812:1: rule__SwitchStatement__Group__7__Impl : ( '}' ) ;

+    public final void rule__SwitchStatement__Group__7__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12816:1: ( ( '}' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12817:1: ( '}' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12817:1: ( '}' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12818:1: '}'

+            {

+             before(grammarAccess.getSwitchStatementAccess().getRightCurlyBracketKeyword_7()); 

+            match(input,88,FOLLOW_88_in_rule__SwitchStatement__Group__7__Impl26242); 

+             after(grammarAccess.getSwitchStatementAccess().getRightCurlyBracketKeyword_7()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__Group__7__Impl"

+

+

+    // $ANTLR start "rule__SwitchClause__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12847:1: rule__SwitchClause__Group__0 : rule__SwitchClause__Group__0__Impl rule__SwitchClause__Group__1 ;

+    public final void rule__SwitchClause__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12851:1: ( rule__SwitchClause__Group__0__Impl rule__SwitchClause__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12852:2: rule__SwitchClause__Group__0__Impl rule__SwitchClause__Group__1

+            {

+            pushFollow(FOLLOW_rule__SwitchClause__Group__0__Impl_in_rule__SwitchClause__Group__026289);

+            rule__SwitchClause__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SwitchClause__Group__1_in_rule__SwitchClause__Group__026292);

+            rule__SwitchClause__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchClause__Group__0"

+

+

+    // $ANTLR start "rule__SwitchClause__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12859:1: rule__SwitchClause__Group__0__Impl : ( ( rule__SwitchClause__SwitchCaseAssignment_0 ) ) ;

+    public final void rule__SwitchClause__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12863:1: ( ( ( rule__SwitchClause__SwitchCaseAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12864:1: ( ( rule__SwitchClause__SwitchCaseAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12864:1: ( ( rule__SwitchClause__SwitchCaseAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12865:1: ( rule__SwitchClause__SwitchCaseAssignment_0 )

+            {

+             before(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12866:1: ( rule__SwitchClause__SwitchCaseAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12866:2: rule__SwitchClause__SwitchCaseAssignment_0

+            {

+            pushFollow(FOLLOW_rule__SwitchClause__SwitchCaseAssignment_0_in_rule__SwitchClause__Group__0__Impl26319);

+            rule__SwitchClause__SwitchCaseAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchClause__Group__0__Impl"

+

+

+    // $ANTLR start "rule__SwitchClause__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12876:1: rule__SwitchClause__Group__1 : rule__SwitchClause__Group__1__Impl rule__SwitchClause__Group__2 ;

+    public final void rule__SwitchClause__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12880:1: ( rule__SwitchClause__Group__1__Impl rule__SwitchClause__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12881:2: rule__SwitchClause__Group__1__Impl rule__SwitchClause__Group__2

+            {

+            pushFollow(FOLLOW_rule__SwitchClause__Group__1__Impl_in_rule__SwitchClause__Group__126349);

+            rule__SwitchClause__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SwitchClause__Group__2_in_rule__SwitchClause__Group__126352);

+            rule__SwitchClause__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchClause__Group__1"

+

+

+    // $ANTLR start "rule__SwitchClause__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12888:1: rule__SwitchClause__Group__1__Impl : ( ( rule__SwitchClause__SwitchCaseAssignment_1 )* ) ;

+    public final void rule__SwitchClause__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12892:1: ( ( ( rule__SwitchClause__SwitchCaseAssignment_1 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12893:1: ( ( rule__SwitchClause__SwitchCaseAssignment_1 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12893:1: ( ( rule__SwitchClause__SwitchCaseAssignment_1 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12894:1: ( rule__SwitchClause__SwitchCaseAssignment_1 )*

+            {

+             before(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12895:1: ( rule__SwitchClause__SwitchCaseAssignment_1 )*

+            loop94:

+            do {

+                int alt94=2;

+                int LA94_0 = input.LA(1);

+

+                if ( (LA94_0==101) ) {

+                    alt94=1;

+                }

+

+

+                switch (alt94) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12895:2: rule__SwitchClause__SwitchCaseAssignment_1

+            	    {

+            	    pushFollow(FOLLOW_rule__SwitchClause__SwitchCaseAssignment_1_in_rule__SwitchClause__Group__1__Impl26379);

+            	    rule__SwitchClause__SwitchCaseAssignment_1();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop94;

+                }

+            } while (true);

+

+             after(grammarAccess.getSwitchClauseAccess().getSwitchCaseAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchClause__Group__1__Impl"

+

+

+    // $ANTLR start "rule__SwitchClause__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12905:1: rule__SwitchClause__Group__2 : rule__SwitchClause__Group__2__Impl ;

+    public final void rule__SwitchClause__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12909:1: ( rule__SwitchClause__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12910:2: rule__SwitchClause__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__SwitchClause__Group__2__Impl_in_rule__SwitchClause__Group__226410);

+            rule__SwitchClause__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchClause__Group__2"

+

+

+    // $ANTLR start "rule__SwitchClause__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12916:1: rule__SwitchClause__Group__2__Impl : ( ( rule__SwitchClause__StatementSequenceAssignment_2 ) ) ;

+    public final void rule__SwitchClause__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12920:1: ( ( ( rule__SwitchClause__StatementSequenceAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12921:1: ( ( rule__SwitchClause__StatementSequenceAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12921:1: ( ( rule__SwitchClause__StatementSequenceAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12922:1: ( rule__SwitchClause__StatementSequenceAssignment_2 )

+            {

+             before(grammarAccess.getSwitchClauseAccess().getStatementSequenceAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12923:1: ( rule__SwitchClause__StatementSequenceAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12923:2: rule__SwitchClause__StatementSequenceAssignment_2

+            {

+            pushFollow(FOLLOW_rule__SwitchClause__StatementSequenceAssignment_2_in_rule__SwitchClause__Group__2__Impl26437);

+            rule__SwitchClause__StatementSequenceAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSwitchClauseAccess().getStatementSequenceAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchClause__Group__2__Impl"

+

+

+    // $ANTLR start "rule__SwitchCase__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12939:1: rule__SwitchCase__Group__0 : rule__SwitchCase__Group__0__Impl rule__SwitchCase__Group__1 ;

+    public final void rule__SwitchCase__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12943:1: ( rule__SwitchCase__Group__0__Impl rule__SwitchCase__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12944:2: rule__SwitchCase__Group__0__Impl rule__SwitchCase__Group__1

+            {

+            pushFollow(FOLLOW_rule__SwitchCase__Group__0__Impl_in_rule__SwitchCase__Group__026473);

+            rule__SwitchCase__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SwitchCase__Group__1_in_rule__SwitchCase__Group__026476);

+            rule__SwitchCase__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchCase__Group__0"

+

+

+    // $ANTLR start "rule__SwitchCase__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12951:1: rule__SwitchCase__Group__0__Impl : ( 'case' ) ;

+    public final void rule__SwitchCase__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12955:1: ( ( 'case' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12956:1: ( 'case' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12956:1: ( 'case' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12957:1: 'case'

+            {

+             before(grammarAccess.getSwitchCaseAccess().getCaseKeyword_0()); 

+            match(input,101,FOLLOW_101_in_rule__SwitchCase__Group__0__Impl26504); 

+             after(grammarAccess.getSwitchCaseAccess().getCaseKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchCase__Group__0__Impl"

+

+

+    // $ANTLR start "rule__SwitchCase__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12970:1: rule__SwitchCase__Group__1 : rule__SwitchCase__Group__1__Impl rule__SwitchCase__Group__2 ;

+    public final void rule__SwitchCase__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12974:1: ( rule__SwitchCase__Group__1__Impl rule__SwitchCase__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12975:2: rule__SwitchCase__Group__1__Impl rule__SwitchCase__Group__2

+            {

+            pushFollow(FOLLOW_rule__SwitchCase__Group__1__Impl_in_rule__SwitchCase__Group__126535);

+            rule__SwitchCase__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SwitchCase__Group__2_in_rule__SwitchCase__Group__126538);

+            rule__SwitchCase__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchCase__Group__1"

+

+

+    // $ANTLR start "rule__SwitchCase__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12982:1: rule__SwitchCase__Group__1__Impl : ( ( rule__SwitchCase__ExpressionAssignment_1 ) ) ;

+    public final void rule__SwitchCase__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12986:1: ( ( ( rule__SwitchCase__ExpressionAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12987:1: ( ( rule__SwitchCase__ExpressionAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12987:1: ( ( rule__SwitchCase__ExpressionAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12988:1: ( rule__SwitchCase__ExpressionAssignment_1 )

+            {

+             before(grammarAccess.getSwitchCaseAccess().getExpressionAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12989:1: ( rule__SwitchCase__ExpressionAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12989:2: rule__SwitchCase__ExpressionAssignment_1

+            {

+            pushFollow(FOLLOW_rule__SwitchCase__ExpressionAssignment_1_in_rule__SwitchCase__Group__1__Impl26565);

+            rule__SwitchCase__ExpressionAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSwitchCaseAccess().getExpressionAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchCase__Group__1__Impl"

+

+

+    // $ANTLR start "rule__SwitchCase__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:12999:1: rule__SwitchCase__Group__2 : rule__SwitchCase__Group__2__Impl ;

+    public final void rule__SwitchCase__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13003:1: ( rule__SwitchCase__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13004:2: rule__SwitchCase__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__SwitchCase__Group__2__Impl_in_rule__SwitchCase__Group__226595);

+            rule__SwitchCase__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchCase__Group__2"

+

+

+    // $ANTLR start "rule__SwitchCase__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13010:1: rule__SwitchCase__Group__2__Impl : ( ':' ) ;

+    public final void rule__SwitchCase__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13014:1: ( ( ':' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13015:1: ( ':' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13015:1: ( ':' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13016:1: ':'

+            {

+             before(grammarAccess.getSwitchCaseAccess().getColonKeyword_2()); 

+            match(input,71,FOLLOW_71_in_rule__SwitchCase__Group__2__Impl26623); 

+             after(grammarAccess.getSwitchCaseAccess().getColonKeyword_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchCase__Group__2__Impl"

+

+

+    // $ANTLR start "rule__SwitchDefaultClause__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13035:1: rule__SwitchDefaultClause__Group__0 : rule__SwitchDefaultClause__Group__0__Impl rule__SwitchDefaultClause__Group__1 ;

+    public final void rule__SwitchDefaultClause__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13039:1: ( rule__SwitchDefaultClause__Group__0__Impl rule__SwitchDefaultClause__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13040:2: rule__SwitchDefaultClause__Group__0__Impl rule__SwitchDefaultClause__Group__1

+            {

+            pushFollow(FOLLOW_rule__SwitchDefaultClause__Group__0__Impl_in_rule__SwitchDefaultClause__Group__026660);

+            rule__SwitchDefaultClause__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SwitchDefaultClause__Group__1_in_rule__SwitchDefaultClause__Group__026663);

+            rule__SwitchDefaultClause__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchDefaultClause__Group__0"

+

+

+    // $ANTLR start "rule__SwitchDefaultClause__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13047:1: rule__SwitchDefaultClause__Group__0__Impl : ( 'default' ) ;

+    public final void rule__SwitchDefaultClause__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13051:1: ( ( 'default' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13052:1: ( 'default' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13052:1: ( 'default' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13053:1: 'default'

+            {

+             before(grammarAccess.getSwitchDefaultClauseAccess().getDefaultKeyword_0()); 

+            match(input,102,FOLLOW_102_in_rule__SwitchDefaultClause__Group__0__Impl26691); 

+             after(grammarAccess.getSwitchDefaultClauseAccess().getDefaultKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchDefaultClause__Group__0__Impl"

+

+

+    // $ANTLR start "rule__SwitchDefaultClause__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13066:1: rule__SwitchDefaultClause__Group__1 : rule__SwitchDefaultClause__Group__1__Impl rule__SwitchDefaultClause__Group__2 ;

+    public final void rule__SwitchDefaultClause__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13070:1: ( rule__SwitchDefaultClause__Group__1__Impl rule__SwitchDefaultClause__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13071:2: rule__SwitchDefaultClause__Group__1__Impl rule__SwitchDefaultClause__Group__2

+            {

+            pushFollow(FOLLOW_rule__SwitchDefaultClause__Group__1__Impl_in_rule__SwitchDefaultClause__Group__126722);

+            rule__SwitchDefaultClause__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SwitchDefaultClause__Group__2_in_rule__SwitchDefaultClause__Group__126725);

+            rule__SwitchDefaultClause__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchDefaultClause__Group__1"

+

+

+    // $ANTLR start "rule__SwitchDefaultClause__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13078:1: rule__SwitchDefaultClause__Group__1__Impl : ( ':' ) ;

+    public final void rule__SwitchDefaultClause__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13082:1: ( ( ':' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13083:1: ( ':' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13083:1: ( ':' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13084:1: ':'

+            {

+             before(grammarAccess.getSwitchDefaultClauseAccess().getColonKeyword_1()); 

+            match(input,71,FOLLOW_71_in_rule__SwitchDefaultClause__Group__1__Impl26753); 

+             after(grammarAccess.getSwitchDefaultClauseAccess().getColonKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchDefaultClause__Group__1__Impl"

+

+

+    // $ANTLR start "rule__SwitchDefaultClause__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13097:1: rule__SwitchDefaultClause__Group__2 : rule__SwitchDefaultClause__Group__2__Impl ;

+    public final void rule__SwitchDefaultClause__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13101:1: ( rule__SwitchDefaultClause__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13102:2: rule__SwitchDefaultClause__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__SwitchDefaultClause__Group__2__Impl_in_rule__SwitchDefaultClause__Group__226784);

+            rule__SwitchDefaultClause__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchDefaultClause__Group__2"

+

+

+    // $ANTLR start "rule__SwitchDefaultClause__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13108:1: rule__SwitchDefaultClause__Group__2__Impl : ( ( rule__SwitchDefaultClause__StatementSequenceAssignment_2 ) ) ;

+    public final void rule__SwitchDefaultClause__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13112:1: ( ( ( rule__SwitchDefaultClause__StatementSequenceAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13113:1: ( ( rule__SwitchDefaultClause__StatementSequenceAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13113:1: ( ( rule__SwitchDefaultClause__StatementSequenceAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13114:1: ( rule__SwitchDefaultClause__StatementSequenceAssignment_2 )

+            {

+             before(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13115:1: ( rule__SwitchDefaultClause__StatementSequenceAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13115:2: rule__SwitchDefaultClause__StatementSequenceAssignment_2

+            {

+            pushFollow(FOLLOW_rule__SwitchDefaultClause__StatementSequenceAssignment_2_in_rule__SwitchDefaultClause__Group__2__Impl26811);

+            rule__SwitchDefaultClause__StatementSequenceAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchDefaultClause__Group__2__Impl"

+

+

+    // $ANTLR start "rule__WhileStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13131:1: rule__WhileStatement__Group__0 : rule__WhileStatement__Group__0__Impl rule__WhileStatement__Group__1 ;

+    public final void rule__WhileStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13135:1: ( rule__WhileStatement__Group__0__Impl rule__WhileStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13136:2: rule__WhileStatement__Group__0__Impl rule__WhileStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__WhileStatement__Group__0__Impl_in_rule__WhileStatement__Group__026847);

+            rule__WhileStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__WhileStatement__Group__1_in_rule__WhileStatement__Group__026850);

+            rule__WhileStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__WhileStatement__Group__0"

+

+

+    // $ANTLR start "rule__WhileStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13143:1: rule__WhileStatement__Group__0__Impl : ( 'while' ) ;

+    public final void rule__WhileStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13147:1: ( ( 'while' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13148:1: ( 'while' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13148:1: ( 'while' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13149:1: 'while'

+            {

+             before(grammarAccess.getWhileStatementAccess().getWhileKeyword_0()); 

+            match(input,103,FOLLOW_103_in_rule__WhileStatement__Group__0__Impl26878); 

+             after(grammarAccess.getWhileStatementAccess().getWhileKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__WhileStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__WhileStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13162:1: rule__WhileStatement__Group__1 : rule__WhileStatement__Group__1__Impl rule__WhileStatement__Group__2 ;

+    public final void rule__WhileStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13166:1: ( rule__WhileStatement__Group__1__Impl rule__WhileStatement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13167:2: rule__WhileStatement__Group__1__Impl rule__WhileStatement__Group__2

+            {

+            pushFollow(FOLLOW_rule__WhileStatement__Group__1__Impl_in_rule__WhileStatement__Group__126909);

+            rule__WhileStatement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__WhileStatement__Group__2_in_rule__WhileStatement__Group__126912);

+            rule__WhileStatement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__WhileStatement__Group__1"

+

+

+    // $ANTLR start "rule__WhileStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13174:1: rule__WhileStatement__Group__1__Impl : ( '(' ) ;

+    public final void rule__WhileStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13178:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13179:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13179:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13180:1: '('

+            {

+             before(grammarAccess.getWhileStatementAccess().getLeftParenthesisKeyword_1()); 

+            match(input,68,FOLLOW_68_in_rule__WhileStatement__Group__1__Impl26940); 

+             after(grammarAccess.getWhileStatementAccess().getLeftParenthesisKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__WhileStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__WhileStatement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13193:1: rule__WhileStatement__Group__2 : rule__WhileStatement__Group__2__Impl rule__WhileStatement__Group__3 ;

+    public final void rule__WhileStatement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13197:1: ( rule__WhileStatement__Group__2__Impl rule__WhileStatement__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13198:2: rule__WhileStatement__Group__2__Impl rule__WhileStatement__Group__3

+            {

+            pushFollow(FOLLOW_rule__WhileStatement__Group__2__Impl_in_rule__WhileStatement__Group__226971);

+            rule__WhileStatement__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__WhileStatement__Group__3_in_rule__WhileStatement__Group__226974);

+            rule__WhileStatement__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__WhileStatement__Group__2"

+

+

+    // $ANTLR start "rule__WhileStatement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13205:1: rule__WhileStatement__Group__2__Impl : ( ( rule__WhileStatement__ConditionAssignment_2 ) ) ;

+    public final void rule__WhileStatement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13209:1: ( ( ( rule__WhileStatement__ConditionAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13210:1: ( ( rule__WhileStatement__ConditionAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13210:1: ( ( rule__WhileStatement__ConditionAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13211:1: ( rule__WhileStatement__ConditionAssignment_2 )

+            {

+             before(grammarAccess.getWhileStatementAccess().getConditionAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13212:1: ( rule__WhileStatement__ConditionAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13212:2: rule__WhileStatement__ConditionAssignment_2

+            {

+            pushFollow(FOLLOW_rule__WhileStatement__ConditionAssignment_2_in_rule__WhileStatement__Group__2__Impl27001);

+            rule__WhileStatement__ConditionAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getWhileStatementAccess().getConditionAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__WhileStatement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__WhileStatement__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13222:1: rule__WhileStatement__Group__3 : rule__WhileStatement__Group__3__Impl rule__WhileStatement__Group__4 ;

+    public final void rule__WhileStatement__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13226:1: ( rule__WhileStatement__Group__3__Impl rule__WhileStatement__Group__4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13227:2: rule__WhileStatement__Group__3__Impl rule__WhileStatement__Group__4

+            {

+            pushFollow(FOLLOW_rule__WhileStatement__Group__3__Impl_in_rule__WhileStatement__Group__327031);

+            rule__WhileStatement__Group__3__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__WhileStatement__Group__4_in_rule__WhileStatement__Group__327034);

+            rule__WhileStatement__Group__4();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__WhileStatement__Group__3"

+

+

+    // $ANTLR start "rule__WhileStatement__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13234:1: rule__WhileStatement__Group__3__Impl : ( ')' ) ;

+    public final void rule__WhileStatement__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13238:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13239:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13239:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13240:1: ')'

+            {

+             before(grammarAccess.getWhileStatementAccess().getRightParenthesisKeyword_3()); 

+            match(input,69,FOLLOW_69_in_rule__WhileStatement__Group__3__Impl27062); 

+             after(grammarAccess.getWhileStatementAccess().getRightParenthesisKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__WhileStatement__Group__3__Impl"

+

+

+    // $ANTLR start "rule__WhileStatement__Group__4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13253:1: rule__WhileStatement__Group__4 : rule__WhileStatement__Group__4__Impl ;

+    public final void rule__WhileStatement__Group__4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13257:1: ( rule__WhileStatement__Group__4__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13258:2: rule__WhileStatement__Group__4__Impl

+            {

+            pushFollow(FOLLOW_rule__WhileStatement__Group__4__Impl_in_rule__WhileStatement__Group__427093);

+            rule__WhileStatement__Group__4__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__WhileStatement__Group__4"

+

+

+    // $ANTLR start "rule__WhileStatement__Group__4__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13264:1: rule__WhileStatement__Group__4__Impl : ( ( rule__WhileStatement__BlockAssignment_4 ) ) ;

+    public final void rule__WhileStatement__Group__4__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13268:1: ( ( ( rule__WhileStatement__BlockAssignment_4 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13269:1: ( ( rule__WhileStatement__BlockAssignment_4 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13269:1: ( ( rule__WhileStatement__BlockAssignment_4 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13270:1: ( rule__WhileStatement__BlockAssignment_4 )

+            {

+             before(grammarAccess.getWhileStatementAccess().getBlockAssignment_4()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13271:1: ( rule__WhileStatement__BlockAssignment_4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13271:2: rule__WhileStatement__BlockAssignment_4

+            {

+            pushFollow(FOLLOW_rule__WhileStatement__BlockAssignment_4_in_rule__WhileStatement__Group__4__Impl27120);

+            rule__WhileStatement__BlockAssignment_4();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getWhileStatementAccess().getBlockAssignment_4()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__WhileStatement__Group__4__Impl"

+

+

+    // $ANTLR start "rule__DoStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13291:1: rule__DoStatement__Group__0 : rule__DoStatement__Group__0__Impl rule__DoStatement__Group__1 ;

+    public final void rule__DoStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13295:1: ( rule__DoStatement__Group__0__Impl rule__DoStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13296:2: rule__DoStatement__Group__0__Impl rule__DoStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__DoStatement__Group__0__Impl_in_rule__DoStatement__Group__027160);

+            rule__DoStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__DoStatement__Group__1_in_rule__DoStatement__Group__027163);

+            rule__DoStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__0"

+

+

+    // $ANTLR start "rule__DoStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13303:1: rule__DoStatement__Group__0__Impl : ( 'do' ) ;

+    public final void rule__DoStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13307:1: ( ( 'do' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13308:1: ( 'do' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13308:1: ( 'do' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13309:1: 'do'

+            {

+             before(grammarAccess.getDoStatementAccess().getDoKeyword_0()); 

+            match(input,104,FOLLOW_104_in_rule__DoStatement__Group__0__Impl27191); 

+             after(grammarAccess.getDoStatementAccess().getDoKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__DoStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13322:1: rule__DoStatement__Group__1 : rule__DoStatement__Group__1__Impl rule__DoStatement__Group__2 ;

+    public final void rule__DoStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13326:1: ( rule__DoStatement__Group__1__Impl rule__DoStatement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13327:2: rule__DoStatement__Group__1__Impl rule__DoStatement__Group__2

+            {

+            pushFollow(FOLLOW_rule__DoStatement__Group__1__Impl_in_rule__DoStatement__Group__127222);

+            rule__DoStatement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__DoStatement__Group__2_in_rule__DoStatement__Group__127225);

+            rule__DoStatement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__1"

+

+

+    // $ANTLR start "rule__DoStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13334:1: rule__DoStatement__Group__1__Impl : ( ( rule__DoStatement__BlockAssignment_1 ) ) ;

+    public final void rule__DoStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13338:1: ( ( ( rule__DoStatement__BlockAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13339:1: ( ( rule__DoStatement__BlockAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13339:1: ( ( rule__DoStatement__BlockAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13340:1: ( rule__DoStatement__BlockAssignment_1 )

+            {

+             before(grammarAccess.getDoStatementAccess().getBlockAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13341:1: ( rule__DoStatement__BlockAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13341:2: rule__DoStatement__BlockAssignment_1

+            {

+            pushFollow(FOLLOW_rule__DoStatement__BlockAssignment_1_in_rule__DoStatement__Group__1__Impl27252);

+            rule__DoStatement__BlockAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getDoStatementAccess().getBlockAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__DoStatement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13351:1: rule__DoStatement__Group__2 : rule__DoStatement__Group__2__Impl rule__DoStatement__Group__3 ;

+    public final void rule__DoStatement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13355:1: ( rule__DoStatement__Group__2__Impl rule__DoStatement__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13356:2: rule__DoStatement__Group__2__Impl rule__DoStatement__Group__3

+            {

+            pushFollow(FOLLOW_rule__DoStatement__Group__2__Impl_in_rule__DoStatement__Group__227282);

+            rule__DoStatement__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__DoStatement__Group__3_in_rule__DoStatement__Group__227285);

+            rule__DoStatement__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__2"

+

+

+    // $ANTLR start "rule__DoStatement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13363:1: rule__DoStatement__Group__2__Impl : ( 'while' ) ;

+    public final void rule__DoStatement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13367:1: ( ( 'while' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13368:1: ( 'while' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13368:1: ( 'while' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13369:1: 'while'

+            {

+             before(grammarAccess.getDoStatementAccess().getWhileKeyword_2()); 

+            match(input,103,FOLLOW_103_in_rule__DoStatement__Group__2__Impl27313); 

+             after(grammarAccess.getDoStatementAccess().getWhileKeyword_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__DoStatement__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13382:1: rule__DoStatement__Group__3 : rule__DoStatement__Group__3__Impl rule__DoStatement__Group__4 ;

+    public final void rule__DoStatement__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13386:1: ( rule__DoStatement__Group__3__Impl rule__DoStatement__Group__4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13387:2: rule__DoStatement__Group__3__Impl rule__DoStatement__Group__4

+            {

+            pushFollow(FOLLOW_rule__DoStatement__Group__3__Impl_in_rule__DoStatement__Group__327344);

+            rule__DoStatement__Group__3__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__DoStatement__Group__4_in_rule__DoStatement__Group__327347);

+            rule__DoStatement__Group__4();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__3"

+

+

+    // $ANTLR start "rule__DoStatement__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13394:1: rule__DoStatement__Group__3__Impl : ( '(' ) ;

+    public final void rule__DoStatement__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13398:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13399:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13399:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13400:1: '('

+            {

+             before(grammarAccess.getDoStatementAccess().getLeftParenthesisKeyword_3()); 

+            match(input,68,FOLLOW_68_in_rule__DoStatement__Group__3__Impl27375); 

+             after(grammarAccess.getDoStatementAccess().getLeftParenthesisKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__3__Impl"

+

+

+    // $ANTLR start "rule__DoStatement__Group__4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13413:1: rule__DoStatement__Group__4 : rule__DoStatement__Group__4__Impl rule__DoStatement__Group__5 ;

+    public final void rule__DoStatement__Group__4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13417:1: ( rule__DoStatement__Group__4__Impl rule__DoStatement__Group__5 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13418:2: rule__DoStatement__Group__4__Impl rule__DoStatement__Group__5

+            {

+            pushFollow(FOLLOW_rule__DoStatement__Group__4__Impl_in_rule__DoStatement__Group__427406);

+            rule__DoStatement__Group__4__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__DoStatement__Group__5_in_rule__DoStatement__Group__427409);

+            rule__DoStatement__Group__5();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__4"

+

+

+    // $ANTLR start "rule__DoStatement__Group__4__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13425:1: rule__DoStatement__Group__4__Impl : ( ( rule__DoStatement__ConditionAssignment_4 ) ) ;

+    public final void rule__DoStatement__Group__4__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13429:1: ( ( ( rule__DoStatement__ConditionAssignment_4 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13430:1: ( ( rule__DoStatement__ConditionAssignment_4 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13430:1: ( ( rule__DoStatement__ConditionAssignment_4 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13431:1: ( rule__DoStatement__ConditionAssignment_4 )

+            {

+             before(grammarAccess.getDoStatementAccess().getConditionAssignment_4()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13432:1: ( rule__DoStatement__ConditionAssignment_4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13432:2: rule__DoStatement__ConditionAssignment_4

+            {

+            pushFollow(FOLLOW_rule__DoStatement__ConditionAssignment_4_in_rule__DoStatement__Group__4__Impl27436);

+            rule__DoStatement__ConditionAssignment_4();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getDoStatementAccess().getConditionAssignment_4()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__4__Impl"

+

+

+    // $ANTLR start "rule__DoStatement__Group__5"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13442:1: rule__DoStatement__Group__5 : rule__DoStatement__Group__5__Impl rule__DoStatement__Group__6 ;

+    public final void rule__DoStatement__Group__5() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13446:1: ( rule__DoStatement__Group__5__Impl rule__DoStatement__Group__6 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13447:2: rule__DoStatement__Group__5__Impl rule__DoStatement__Group__6

+            {

+            pushFollow(FOLLOW_rule__DoStatement__Group__5__Impl_in_rule__DoStatement__Group__527466);

+            rule__DoStatement__Group__5__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__DoStatement__Group__6_in_rule__DoStatement__Group__527469);

+            rule__DoStatement__Group__6();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__5"

+

+

+    // $ANTLR start "rule__DoStatement__Group__5__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13454:1: rule__DoStatement__Group__5__Impl : ( ')' ) ;

+    public final void rule__DoStatement__Group__5__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13458:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13459:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13459:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13460:1: ')'

+            {

+             before(grammarAccess.getDoStatementAccess().getRightParenthesisKeyword_5()); 

+            match(input,69,FOLLOW_69_in_rule__DoStatement__Group__5__Impl27497); 

+             after(grammarAccess.getDoStatementAccess().getRightParenthesisKeyword_5()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__5__Impl"

+

+

+    // $ANTLR start "rule__DoStatement__Group__6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13473:1: rule__DoStatement__Group__6 : rule__DoStatement__Group__6__Impl ;

+    public final void rule__DoStatement__Group__6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13477:1: ( rule__DoStatement__Group__6__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13478:2: rule__DoStatement__Group__6__Impl

+            {

+            pushFollow(FOLLOW_rule__DoStatement__Group__6__Impl_in_rule__DoStatement__Group__627528);

+            rule__DoStatement__Group__6__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__6"

+

+

+    // $ANTLR start "rule__DoStatement__Group__6__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13484:1: rule__DoStatement__Group__6__Impl : ( ';' ) ;

+    public final void rule__DoStatement__Group__6__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13488:1: ( ( ';' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13489:1: ( ';' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13489:1: ( ';' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13490:1: ';'

+            {

+             before(grammarAccess.getDoStatementAccess().getSemicolonKeyword_6()); 

+            match(input,95,FOLLOW_95_in_rule__DoStatement__Group__6__Impl27556); 

+             after(grammarAccess.getDoStatementAccess().getSemicolonKeyword_6()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__Group__6__Impl"

+

+

+    // $ANTLR start "rule__ForStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13517:1: rule__ForStatement__Group__0 : rule__ForStatement__Group__0__Impl rule__ForStatement__Group__1 ;

+    public final void rule__ForStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13521:1: ( rule__ForStatement__Group__0__Impl rule__ForStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13522:2: rule__ForStatement__Group__0__Impl rule__ForStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__ForStatement__Group__0__Impl_in_rule__ForStatement__Group__027601);

+            rule__ForStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ForStatement__Group__1_in_rule__ForStatement__Group__027604);

+            rule__ForStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForStatement__Group__0"

+

+

+    // $ANTLR start "rule__ForStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13529:1: rule__ForStatement__Group__0__Impl : ( 'for' ) ;

+    public final void rule__ForStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13533:1: ( ( 'for' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13534:1: ( 'for' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13534:1: ( 'for' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13535:1: 'for'

+            {

+             before(grammarAccess.getForStatementAccess().getForKeyword_0()); 

+            match(input,105,FOLLOW_105_in_rule__ForStatement__Group__0__Impl27632); 

+             after(grammarAccess.getForStatementAccess().getForKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ForStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13548:1: rule__ForStatement__Group__1 : rule__ForStatement__Group__1__Impl rule__ForStatement__Group__2 ;

+    public final void rule__ForStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13552:1: ( rule__ForStatement__Group__1__Impl rule__ForStatement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13553:2: rule__ForStatement__Group__1__Impl rule__ForStatement__Group__2

+            {

+            pushFollow(FOLLOW_rule__ForStatement__Group__1__Impl_in_rule__ForStatement__Group__127663);

+            rule__ForStatement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ForStatement__Group__2_in_rule__ForStatement__Group__127666);

+            rule__ForStatement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForStatement__Group__1"

+

+

+    // $ANTLR start "rule__ForStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13560:1: rule__ForStatement__Group__1__Impl : ( '(' ) ;

+    public final void rule__ForStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13564:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13565:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13565:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13566:1: '('

+            {

+             before(grammarAccess.getForStatementAccess().getLeftParenthesisKeyword_1()); 

+            match(input,68,FOLLOW_68_in_rule__ForStatement__Group__1__Impl27694); 

+             after(grammarAccess.getForStatementAccess().getLeftParenthesisKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ForStatement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13579:1: rule__ForStatement__Group__2 : rule__ForStatement__Group__2__Impl rule__ForStatement__Group__3 ;

+    public final void rule__ForStatement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13583:1: ( rule__ForStatement__Group__2__Impl rule__ForStatement__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13584:2: rule__ForStatement__Group__2__Impl rule__ForStatement__Group__3

+            {

+            pushFollow(FOLLOW_rule__ForStatement__Group__2__Impl_in_rule__ForStatement__Group__227725);

+            rule__ForStatement__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ForStatement__Group__3_in_rule__ForStatement__Group__227728);

+            rule__ForStatement__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForStatement__Group__2"

+

+

+    // $ANTLR start "rule__ForStatement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13591:1: rule__ForStatement__Group__2__Impl : ( ( rule__ForStatement__ControlAssignment_2 ) ) ;

+    public final void rule__ForStatement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13595:1: ( ( ( rule__ForStatement__ControlAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13596:1: ( ( rule__ForStatement__ControlAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13596:1: ( ( rule__ForStatement__ControlAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13597:1: ( rule__ForStatement__ControlAssignment_2 )

+            {

+             before(grammarAccess.getForStatementAccess().getControlAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13598:1: ( rule__ForStatement__ControlAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13598:2: rule__ForStatement__ControlAssignment_2

+            {

+            pushFollow(FOLLOW_rule__ForStatement__ControlAssignment_2_in_rule__ForStatement__Group__2__Impl27755);

+            rule__ForStatement__ControlAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getForStatementAccess().getControlAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForStatement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__ForStatement__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13608:1: rule__ForStatement__Group__3 : rule__ForStatement__Group__3__Impl rule__ForStatement__Group__4 ;

+    public final void rule__ForStatement__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13612:1: ( rule__ForStatement__Group__3__Impl rule__ForStatement__Group__4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13613:2: rule__ForStatement__Group__3__Impl rule__ForStatement__Group__4

+            {

+            pushFollow(FOLLOW_rule__ForStatement__Group__3__Impl_in_rule__ForStatement__Group__327785);

+            rule__ForStatement__Group__3__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ForStatement__Group__4_in_rule__ForStatement__Group__327788);

+            rule__ForStatement__Group__4();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForStatement__Group__3"

+

+

+    // $ANTLR start "rule__ForStatement__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13620:1: rule__ForStatement__Group__3__Impl : ( ')' ) ;

+    public final void rule__ForStatement__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13624:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13625:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13625:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13626:1: ')'

+            {

+             before(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_3()); 

+            match(input,69,FOLLOW_69_in_rule__ForStatement__Group__3__Impl27816); 

+             after(grammarAccess.getForStatementAccess().getRightParenthesisKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForStatement__Group__3__Impl"

+

+

+    // $ANTLR start "rule__ForStatement__Group__4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13639:1: rule__ForStatement__Group__4 : rule__ForStatement__Group__4__Impl ;

+    public final void rule__ForStatement__Group__4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13643:1: ( rule__ForStatement__Group__4__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13644:2: rule__ForStatement__Group__4__Impl

+            {

+            pushFollow(FOLLOW_rule__ForStatement__Group__4__Impl_in_rule__ForStatement__Group__427847);

+            rule__ForStatement__Group__4__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForStatement__Group__4"

+

+

+    // $ANTLR start "rule__ForStatement__Group__4__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13650:1: rule__ForStatement__Group__4__Impl : ( ( rule__ForStatement__BlockAssignment_4 ) ) ;

+    public final void rule__ForStatement__Group__4__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13654:1: ( ( ( rule__ForStatement__BlockAssignment_4 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13655:1: ( ( rule__ForStatement__BlockAssignment_4 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13655:1: ( ( rule__ForStatement__BlockAssignment_4 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13656:1: ( rule__ForStatement__BlockAssignment_4 )

+            {

+             before(grammarAccess.getForStatementAccess().getBlockAssignment_4()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13657:1: ( rule__ForStatement__BlockAssignment_4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13657:2: rule__ForStatement__BlockAssignment_4

+            {

+            pushFollow(FOLLOW_rule__ForStatement__BlockAssignment_4_in_rule__ForStatement__Group__4__Impl27874);

+            rule__ForStatement__BlockAssignment_4();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getForStatementAccess().getBlockAssignment_4()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForStatement__Group__4__Impl"

+

+

+    // $ANTLR start "rule__ForControl__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13677:1: rule__ForControl__Group__0 : rule__ForControl__Group__0__Impl rule__ForControl__Group__1 ;

+    public final void rule__ForControl__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13681:1: ( rule__ForControl__Group__0__Impl rule__ForControl__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13682:2: rule__ForControl__Group__0__Impl rule__ForControl__Group__1

+            {

+            pushFollow(FOLLOW_rule__ForControl__Group__0__Impl_in_rule__ForControl__Group__027914);

+            rule__ForControl__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ForControl__Group__1_in_rule__ForControl__Group__027917);

+            rule__ForControl__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForControl__Group__0"

+

+

+    // $ANTLR start "rule__ForControl__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13689:1: rule__ForControl__Group__0__Impl : ( ( rule__ForControl__LoopVariableDefinitionAssignment_0 ) ) ;

+    public final void rule__ForControl__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13693:1: ( ( ( rule__ForControl__LoopVariableDefinitionAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13694:1: ( ( rule__ForControl__LoopVariableDefinitionAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13694:1: ( ( rule__ForControl__LoopVariableDefinitionAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13695:1: ( rule__ForControl__LoopVariableDefinitionAssignment_0 )

+            {

+             before(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13696:1: ( rule__ForControl__LoopVariableDefinitionAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13696:2: rule__ForControl__LoopVariableDefinitionAssignment_0

+            {

+            pushFollow(FOLLOW_rule__ForControl__LoopVariableDefinitionAssignment_0_in_rule__ForControl__Group__0__Impl27944);

+            rule__ForControl__LoopVariableDefinitionAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForControl__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ForControl__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13706:1: rule__ForControl__Group__1 : rule__ForControl__Group__1__Impl ;

+    public final void rule__ForControl__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13710:1: ( rule__ForControl__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13711:2: rule__ForControl__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ForControl__Group__1__Impl_in_rule__ForControl__Group__127974);

+            rule__ForControl__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForControl__Group__1"

+

+

+    // $ANTLR start "rule__ForControl__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13717:1: rule__ForControl__Group__1__Impl : ( ( rule__ForControl__Group_1__0 )* ) ;

+    public final void rule__ForControl__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13721:1: ( ( ( rule__ForControl__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13722:1: ( ( rule__ForControl__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13722:1: ( ( rule__ForControl__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13723:1: ( rule__ForControl__Group_1__0 )*

+            {

+             before(grammarAccess.getForControlAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13724:1: ( rule__ForControl__Group_1__0 )*

+            loop95:

+            do {

+                int alt95=2;

+                int LA95_0 = input.LA(1);

+

+                if ( (LA95_0==66) ) {

+                    alt95=1;

+                }

+

+

+                switch (alt95) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13724:2: rule__ForControl__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__ForControl__Group_1__0_in_rule__ForControl__Group__1__Impl28001);

+            	    rule__ForControl__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop95;

+                }

+            } while (true);

+

+             after(grammarAccess.getForControlAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForControl__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ForControl__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13738:1: rule__ForControl__Group_1__0 : rule__ForControl__Group_1__0__Impl rule__ForControl__Group_1__1 ;

+    public final void rule__ForControl__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13742:1: ( rule__ForControl__Group_1__0__Impl rule__ForControl__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13743:2: rule__ForControl__Group_1__0__Impl rule__ForControl__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__ForControl__Group_1__0__Impl_in_rule__ForControl__Group_1__028036);

+            rule__ForControl__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ForControl__Group_1__1_in_rule__ForControl__Group_1__028039);

+            rule__ForControl__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForControl__Group_1__0"

+

+

+    // $ANTLR start "rule__ForControl__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13750:1: rule__ForControl__Group_1__0__Impl : ( ',' ) ;

+    public final void rule__ForControl__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13754:1: ( ( ',' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13755:1: ( ',' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13755:1: ( ',' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13756:1: ','

+            {

+             before(grammarAccess.getForControlAccess().getCommaKeyword_1_0()); 

+            match(input,66,FOLLOW_66_in_rule__ForControl__Group_1__0__Impl28067); 

+             after(grammarAccess.getForControlAccess().getCommaKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForControl__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__ForControl__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13769:1: rule__ForControl__Group_1__1 : rule__ForControl__Group_1__1__Impl ;

+    public final void rule__ForControl__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13773:1: ( rule__ForControl__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13774:2: rule__ForControl__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ForControl__Group_1__1__Impl_in_rule__ForControl__Group_1__128098);

+            rule__ForControl__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForControl__Group_1__1"

+

+

+    // $ANTLR start "rule__ForControl__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13780:1: rule__ForControl__Group_1__1__Impl : ( ( rule__ForControl__LoopVariableDefinitionAssignment_1_1 ) ) ;

+    public final void rule__ForControl__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13784:1: ( ( ( rule__ForControl__LoopVariableDefinitionAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13785:1: ( ( rule__ForControl__LoopVariableDefinitionAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13785:1: ( ( rule__ForControl__LoopVariableDefinitionAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13786:1: ( rule__ForControl__LoopVariableDefinitionAssignment_1_1 )

+            {

+             before(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13787:1: ( rule__ForControl__LoopVariableDefinitionAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13787:2: rule__ForControl__LoopVariableDefinitionAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__ForControl__LoopVariableDefinitionAssignment_1_1_in_rule__ForControl__Group_1__1__Impl28125);

+            rule__ForControl__LoopVariableDefinitionAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getForControlAccess().getLoopVariableDefinitionAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForControl__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_0__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13801:1: rule__LoopVariableDefinition__Group_0__0 : rule__LoopVariableDefinition__Group_0__0__Impl rule__LoopVariableDefinition__Group_0__1 ;

+    public final void rule__LoopVariableDefinition__Group_0__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13805:1: ( rule__LoopVariableDefinition__Group_0__0__Impl rule__LoopVariableDefinition__Group_0__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13806:2: rule__LoopVariableDefinition__Group_0__0__Impl rule__LoopVariableDefinition__Group_0__1

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_0__0__Impl_in_rule__LoopVariableDefinition__Group_0__028159);

+            rule__LoopVariableDefinition__Group_0__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_0__1_in_rule__LoopVariableDefinition__Group_0__028162);

+            rule__LoopVariableDefinition__Group_0__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_0__0"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_0__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13813:1: rule__LoopVariableDefinition__Group_0__0__Impl : ( ( rule__LoopVariableDefinition__NameAssignment_0_0 ) ) ;

+    public final void rule__LoopVariableDefinition__Group_0__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13817:1: ( ( ( rule__LoopVariableDefinition__NameAssignment_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13818:1: ( ( rule__LoopVariableDefinition__NameAssignment_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13818:1: ( ( rule__LoopVariableDefinition__NameAssignment_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13819:1: ( rule__LoopVariableDefinition__NameAssignment_0_0 )

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13820:1: ( rule__LoopVariableDefinition__NameAssignment_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13820:2: rule__LoopVariableDefinition__NameAssignment_0_0

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__NameAssignment_0_0_in_rule__LoopVariableDefinition__Group_0__0__Impl28189);

+            rule__LoopVariableDefinition__NameAssignment_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_0__0__Impl"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_0__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13830:1: rule__LoopVariableDefinition__Group_0__1 : rule__LoopVariableDefinition__Group_0__1__Impl rule__LoopVariableDefinition__Group_0__2 ;

+    public final void rule__LoopVariableDefinition__Group_0__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13834:1: ( rule__LoopVariableDefinition__Group_0__1__Impl rule__LoopVariableDefinition__Group_0__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13835:2: rule__LoopVariableDefinition__Group_0__1__Impl rule__LoopVariableDefinition__Group_0__2

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_0__1__Impl_in_rule__LoopVariableDefinition__Group_0__128219);

+            rule__LoopVariableDefinition__Group_0__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_0__2_in_rule__LoopVariableDefinition__Group_0__128222);

+            rule__LoopVariableDefinition__Group_0__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_0__1"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_0__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13842:1: rule__LoopVariableDefinition__Group_0__1__Impl : ( 'in' ) ;

+    public final void rule__LoopVariableDefinition__Group_0__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13846:1: ( ( 'in' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13847:1: ( 'in' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13847:1: ( 'in' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13848:1: 'in'

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getInKeyword_0_1()); 

+            match(input,106,FOLLOW_106_in_rule__LoopVariableDefinition__Group_0__1__Impl28250); 

+             after(grammarAccess.getLoopVariableDefinitionAccess().getInKeyword_0_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_0__1__Impl"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_0__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13861:1: rule__LoopVariableDefinition__Group_0__2 : rule__LoopVariableDefinition__Group_0__2__Impl rule__LoopVariableDefinition__Group_0__3 ;

+    public final void rule__LoopVariableDefinition__Group_0__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13865:1: ( rule__LoopVariableDefinition__Group_0__2__Impl rule__LoopVariableDefinition__Group_0__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13866:2: rule__LoopVariableDefinition__Group_0__2__Impl rule__LoopVariableDefinition__Group_0__3

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_0__2__Impl_in_rule__LoopVariableDefinition__Group_0__228281);

+            rule__LoopVariableDefinition__Group_0__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_0__3_in_rule__LoopVariableDefinition__Group_0__228284);

+            rule__LoopVariableDefinition__Group_0__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_0__2"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_0__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13873:1: rule__LoopVariableDefinition__Group_0__2__Impl : ( ( rule__LoopVariableDefinition__Expression1Assignment_0_2 ) ) ;

+    public final void rule__LoopVariableDefinition__Group_0__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13877:1: ( ( ( rule__LoopVariableDefinition__Expression1Assignment_0_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13878:1: ( ( rule__LoopVariableDefinition__Expression1Assignment_0_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13878:1: ( ( rule__LoopVariableDefinition__Expression1Assignment_0_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13879:1: ( rule__LoopVariableDefinition__Expression1Assignment_0_2 )

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getExpression1Assignment_0_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13880:1: ( rule__LoopVariableDefinition__Expression1Assignment_0_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13880:2: rule__LoopVariableDefinition__Expression1Assignment_0_2

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Expression1Assignment_0_2_in_rule__LoopVariableDefinition__Group_0__2__Impl28311);

+            rule__LoopVariableDefinition__Expression1Assignment_0_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLoopVariableDefinitionAccess().getExpression1Assignment_0_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_0__2__Impl"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_0__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13890:1: rule__LoopVariableDefinition__Group_0__3 : rule__LoopVariableDefinition__Group_0__3__Impl ;

+    public final void rule__LoopVariableDefinition__Group_0__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13894:1: ( rule__LoopVariableDefinition__Group_0__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13895:2: rule__LoopVariableDefinition__Group_0__3__Impl

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_0__3__Impl_in_rule__LoopVariableDefinition__Group_0__328341);

+            rule__LoopVariableDefinition__Group_0__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_0__3"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_0__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13901:1: rule__LoopVariableDefinition__Group_0__3__Impl : ( ( rule__LoopVariableDefinition__Group_0_3__0 )? ) ;

+    public final void rule__LoopVariableDefinition__Group_0__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13905:1: ( ( ( rule__LoopVariableDefinition__Group_0_3__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13906:1: ( ( rule__LoopVariableDefinition__Group_0_3__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13906:1: ( ( rule__LoopVariableDefinition__Group_0_3__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13907:1: ( rule__LoopVariableDefinition__Group_0_3__0 )?

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13908:1: ( rule__LoopVariableDefinition__Group_0_3__0 )?

+            int alt96=2;

+            int LA96_0 = input.LA(1);

+

+            if ( (LA96_0==89) ) {

+                alt96=1;

+            }

+            switch (alt96) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13908:2: rule__LoopVariableDefinition__Group_0_3__0

+                    {

+                    pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_0_3__0_in_rule__LoopVariableDefinition__Group_0__3__Impl28368);

+                    rule__LoopVariableDefinition__Group_0_3__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getLoopVariableDefinitionAccess().getGroup_0_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_0__3__Impl"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_0_3__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13926:1: rule__LoopVariableDefinition__Group_0_3__0 : rule__LoopVariableDefinition__Group_0_3__0__Impl rule__LoopVariableDefinition__Group_0_3__1 ;

+    public final void rule__LoopVariableDefinition__Group_0_3__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13930:1: ( rule__LoopVariableDefinition__Group_0_3__0__Impl rule__LoopVariableDefinition__Group_0_3__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13931:2: rule__LoopVariableDefinition__Group_0_3__0__Impl rule__LoopVariableDefinition__Group_0_3__1

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_0_3__0__Impl_in_rule__LoopVariableDefinition__Group_0_3__028407);

+            rule__LoopVariableDefinition__Group_0_3__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_0_3__1_in_rule__LoopVariableDefinition__Group_0_3__028410);

+            rule__LoopVariableDefinition__Group_0_3__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_0_3__0"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_0_3__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13938:1: rule__LoopVariableDefinition__Group_0_3__0__Impl : ( '..' ) ;

+    public final void rule__LoopVariableDefinition__Group_0_3__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13942:1: ( ( '..' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13943:1: ( '..' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13943:1: ( '..' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13944:1: '..'

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getFullStopFullStopKeyword_0_3_0()); 

+            match(input,89,FOLLOW_89_in_rule__LoopVariableDefinition__Group_0_3__0__Impl28438); 

+             after(grammarAccess.getLoopVariableDefinitionAccess().getFullStopFullStopKeyword_0_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_0_3__0__Impl"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_0_3__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13957:1: rule__LoopVariableDefinition__Group_0_3__1 : rule__LoopVariableDefinition__Group_0_3__1__Impl ;

+    public final void rule__LoopVariableDefinition__Group_0_3__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13961:1: ( rule__LoopVariableDefinition__Group_0_3__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13962:2: rule__LoopVariableDefinition__Group_0_3__1__Impl

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_0_3__1__Impl_in_rule__LoopVariableDefinition__Group_0_3__128469);

+            rule__LoopVariableDefinition__Group_0_3__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_0_3__1"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_0_3__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13968:1: rule__LoopVariableDefinition__Group_0_3__1__Impl : ( ( rule__LoopVariableDefinition__Expression2Assignment_0_3_1 ) ) ;

+    public final void rule__LoopVariableDefinition__Group_0_3__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13972:1: ( ( ( rule__LoopVariableDefinition__Expression2Assignment_0_3_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13973:1: ( ( rule__LoopVariableDefinition__Expression2Assignment_0_3_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13973:1: ( ( rule__LoopVariableDefinition__Expression2Assignment_0_3_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13974:1: ( rule__LoopVariableDefinition__Expression2Assignment_0_3_1 )

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getExpression2Assignment_0_3_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13975:1: ( rule__LoopVariableDefinition__Expression2Assignment_0_3_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13975:2: rule__LoopVariableDefinition__Expression2Assignment_0_3_1

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Expression2Assignment_0_3_1_in_rule__LoopVariableDefinition__Group_0_3__1__Impl28496);

+            rule__LoopVariableDefinition__Expression2Assignment_0_3_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLoopVariableDefinitionAccess().getExpression2Assignment_0_3_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_0_3__1__Impl"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13989:1: rule__LoopVariableDefinition__Group_1__0 : rule__LoopVariableDefinition__Group_1__0__Impl rule__LoopVariableDefinition__Group_1__1 ;

+    public final void rule__LoopVariableDefinition__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13993:1: ( rule__LoopVariableDefinition__Group_1__0__Impl rule__LoopVariableDefinition__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:13994:2: rule__LoopVariableDefinition__Group_1__0__Impl rule__LoopVariableDefinition__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_1__0__Impl_in_rule__LoopVariableDefinition__Group_1__028530);

+            rule__LoopVariableDefinition__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_1__1_in_rule__LoopVariableDefinition__Group_1__028533);

+            rule__LoopVariableDefinition__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_1__0"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14001:1: rule__LoopVariableDefinition__Group_1__0__Impl : ( ( rule__LoopVariableDefinition__TypeAssignment_1_0 ) ) ;

+    public final void rule__LoopVariableDefinition__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14005:1: ( ( ( rule__LoopVariableDefinition__TypeAssignment_1_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14006:1: ( ( rule__LoopVariableDefinition__TypeAssignment_1_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14006:1: ( ( rule__LoopVariableDefinition__TypeAssignment_1_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14007:1: ( rule__LoopVariableDefinition__TypeAssignment_1_0 )

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getTypeAssignment_1_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14008:1: ( rule__LoopVariableDefinition__TypeAssignment_1_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14008:2: rule__LoopVariableDefinition__TypeAssignment_1_0

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__TypeAssignment_1_0_in_rule__LoopVariableDefinition__Group_1__0__Impl28560);

+            rule__LoopVariableDefinition__TypeAssignment_1_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLoopVariableDefinitionAccess().getTypeAssignment_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14018:1: rule__LoopVariableDefinition__Group_1__1 : rule__LoopVariableDefinition__Group_1__1__Impl rule__LoopVariableDefinition__Group_1__2 ;

+    public final void rule__LoopVariableDefinition__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14022:1: ( rule__LoopVariableDefinition__Group_1__1__Impl rule__LoopVariableDefinition__Group_1__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14023:2: rule__LoopVariableDefinition__Group_1__1__Impl rule__LoopVariableDefinition__Group_1__2

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_1__1__Impl_in_rule__LoopVariableDefinition__Group_1__128590);

+            rule__LoopVariableDefinition__Group_1__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_1__2_in_rule__LoopVariableDefinition__Group_1__128593);

+            rule__LoopVariableDefinition__Group_1__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_1__1"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14030:1: rule__LoopVariableDefinition__Group_1__1__Impl : ( ( rule__LoopVariableDefinition__NameAssignment_1_1 ) ) ;

+    public final void rule__LoopVariableDefinition__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14034:1: ( ( ( rule__LoopVariableDefinition__NameAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14035:1: ( ( rule__LoopVariableDefinition__NameAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14035:1: ( ( rule__LoopVariableDefinition__NameAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14036:1: ( rule__LoopVariableDefinition__NameAssignment_1_1 )

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14037:1: ( rule__LoopVariableDefinition__NameAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14037:2: rule__LoopVariableDefinition__NameAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__NameAssignment_1_1_in_rule__LoopVariableDefinition__Group_1__1__Impl28620);

+            rule__LoopVariableDefinition__NameAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLoopVariableDefinitionAccess().getNameAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_1__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14047:1: rule__LoopVariableDefinition__Group_1__2 : rule__LoopVariableDefinition__Group_1__2__Impl rule__LoopVariableDefinition__Group_1__3 ;

+    public final void rule__LoopVariableDefinition__Group_1__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14051:1: ( rule__LoopVariableDefinition__Group_1__2__Impl rule__LoopVariableDefinition__Group_1__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14052:2: rule__LoopVariableDefinition__Group_1__2__Impl rule__LoopVariableDefinition__Group_1__3

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_1__2__Impl_in_rule__LoopVariableDefinition__Group_1__228650);

+            rule__LoopVariableDefinition__Group_1__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_1__3_in_rule__LoopVariableDefinition__Group_1__228653);

+            rule__LoopVariableDefinition__Group_1__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_1__2"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_1__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14059:1: rule__LoopVariableDefinition__Group_1__2__Impl : ( ':' ) ;

+    public final void rule__LoopVariableDefinition__Group_1__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14063:1: ( ( ':' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14064:1: ( ':' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14064:1: ( ':' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14065:1: ':'

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getColonKeyword_1_2()); 

+            match(input,71,FOLLOW_71_in_rule__LoopVariableDefinition__Group_1__2__Impl28681); 

+             after(grammarAccess.getLoopVariableDefinitionAccess().getColonKeyword_1_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_1__2__Impl"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_1__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14078:1: rule__LoopVariableDefinition__Group_1__3 : rule__LoopVariableDefinition__Group_1__3__Impl ;

+    public final void rule__LoopVariableDefinition__Group_1__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14082:1: ( rule__LoopVariableDefinition__Group_1__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14083:2: rule__LoopVariableDefinition__Group_1__3__Impl

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__Group_1__3__Impl_in_rule__LoopVariableDefinition__Group_1__328712);

+            rule__LoopVariableDefinition__Group_1__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_1__3"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Group_1__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14089:1: rule__LoopVariableDefinition__Group_1__3__Impl : ( ( rule__LoopVariableDefinition__ExpressionAssignment_1_3 ) ) ;

+    public final void rule__LoopVariableDefinition__Group_1__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14093:1: ( ( ( rule__LoopVariableDefinition__ExpressionAssignment_1_3 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14094:1: ( ( rule__LoopVariableDefinition__ExpressionAssignment_1_3 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14094:1: ( ( rule__LoopVariableDefinition__ExpressionAssignment_1_3 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14095:1: ( rule__LoopVariableDefinition__ExpressionAssignment_1_3 )

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getExpressionAssignment_1_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14096:1: ( rule__LoopVariableDefinition__ExpressionAssignment_1_3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14096:2: rule__LoopVariableDefinition__ExpressionAssignment_1_3

+            {

+            pushFollow(FOLLOW_rule__LoopVariableDefinition__ExpressionAssignment_1_3_in_rule__LoopVariableDefinition__Group_1__3__Impl28739);

+            rule__LoopVariableDefinition__ExpressionAssignment_1_3();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getLoopVariableDefinitionAccess().getExpressionAssignment_1_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Group_1__3__Impl"

+

+

+    // $ANTLR start "rule__BreakStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14114:1: rule__BreakStatement__Group__0 : rule__BreakStatement__Group__0__Impl rule__BreakStatement__Group__1 ;

+    public final void rule__BreakStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14118:1: ( rule__BreakStatement__Group__0__Impl rule__BreakStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14119:2: rule__BreakStatement__Group__0__Impl rule__BreakStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__BreakStatement__Group__0__Impl_in_rule__BreakStatement__Group__028777);

+            rule__BreakStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__BreakStatement__Group__1_in_rule__BreakStatement__Group__028780);

+            rule__BreakStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__BreakStatement__Group__0"

+

+

+    // $ANTLR start "rule__BreakStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14126:1: rule__BreakStatement__Group__0__Impl : ( () ) ;

+    public final void rule__BreakStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14130:1: ( ( () ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14131:1: ( () )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14131:1: ( () )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14132:1: ()

+            {

+             before(grammarAccess.getBreakStatementAccess().getBreakStatementAction_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14133:1: ()

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14135:1: 

+            {

+            }

+

+             after(grammarAccess.getBreakStatementAccess().getBreakStatementAction_0()); 

+

+            }

+

+

+            }

+

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__BreakStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__BreakStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14145:1: rule__BreakStatement__Group__1 : rule__BreakStatement__Group__1__Impl rule__BreakStatement__Group__2 ;

+    public final void rule__BreakStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14149:1: ( rule__BreakStatement__Group__1__Impl rule__BreakStatement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14150:2: rule__BreakStatement__Group__1__Impl rule__BreakStatement__Group__2

+            {

+            pushFollow(FOLLOW_rule__BreakStatement__Group__1__Impl_in_rule__BreakStatement__Group__128838);

+            rule__BreakStatement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__BreakStatement__Group__2_in_rule__BreakStatement__Group__128841);

+            rule__BreakStatement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__BreakStatement__Group__1"

+

+

+    // $ANTLR start "rule__BreakStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14157:1: rule__BreakStatement__Group__1__Impl : ( 'break' ) ;

+    public final void rule__BreakStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14161:1: ( ( 'break' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14162:1: ( 'break' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14162:1: ( 'break' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14163:1: 'break'

+            {

+             before(grammarAccess.getBreakStatementAccess().getBreakKeyword_1()); 

+            match(input,107,FOLLOW_107_in_rule__BreakStatement__Group__1__Impl28869); 

+             after(grammarAccess.getBreakStatementAccess().getBreakKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__BreakStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__BreakStatement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14176:1: rule__BreakStatement__Group__2 : rule__BreakStatement__Group__2__Impl ;

+    public final void rule__BreakStatement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14180:1: ( rule__BreakStatement__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14181:2: rule__BreakStatement__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__BreakStatement__Group__2__Impl_in_rule__BreakStatement__Group__228900);

+            rule__BreakStatement__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__BreakStatement__Group__2"

+

+

+    // $ANTLR start "rule__BreakStatement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14187:1: rule__BreakStatement__Group__2__Impl : ( ';' ) ;

+    public final void rule__BreakStatement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14191:1: ( ( ';' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14192:1: ( ';' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14192:1: ( ';' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14193:1: ';'

+            {

+             before(grammarAccess.getBreakStatementAccess().getSemicolonKeyword_2()); 

+            match(input,95,FOLLOW_95_in_rule__BreakStatement__Group__2__Impl28928); 

+             after(grammarAccess.getBreakStatementAccess().getSemicolonKeyword_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__BreakStatement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__ReturnStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14212:1: rule__ReturnStatement__Group__0 : rule__ReturnStatement__Group__0__Impl rule__ReturnStatement__Group__1 ;

+    public final void rule__ReturnStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14216:1: ( rule__ReturnStatement__Group__0__Impl rule__ReturnStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14217:2: rule__ReturnStatement__Group__0__Impl rule__ReturnStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__ReturnStatement__Group__0__Impl_in_rule__ReturnStatement__Group__028965);

+            rule__ReturnStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ReturnStatement__Group__1_in_rule__ReturnStatement__Group__028968);

+            rule__ReturnStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ReturnStatement__Group__0"

+

+

+    // $ANTLR start "rule__ReturnStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14224:1: rule__ReturnStatement__Group__0__Impl : ( 'return' ) ;

+    public final void rule__ReturnStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14228:1: ( ( 'return' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14229:1: ( 'return' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14229:1: ( 'return' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14230:1: 'return'

+            {

+             before(grammarAccess.getReturnStatementAccess().getReturnKeyword_0()); 

+            match(input,108,FOLLOW_108_in_rule__ReturnStatement__Group__0__Impl28996); 

+             after(grammarAccess.getReturnStatementAccess().getReturnKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ReturnStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ReturnStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14243:1: rule__ReturnStatement__Group__1 : rule__ReturnStatement__Group__1__Impl rule__ReturnStatement__Group__2 ;

+    public final void rule__ReturnStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14247:1: ( rule__ReturnStatement__Group__1__Impl rule__ReturnStatement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14248:2: rule__ReturnStatement__Group__1__Impl rule__ReturnStatement__Group__2

+            {

+            pushFollow(FOLLOW_rule__ReturnStatement__Group__1__Impl_in_rule__ReturnStatement__Group__129027);

+            rule__ReturnStatement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ReturnStatement__Group__2_in_rule__ReturnStatement__Group__129030);

+            rule__ReturnStatement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ReturnStatement__Group__1"

+

+

+    // $ANTLR start "rule__ReturnStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14255:1: rule__ReturnStatement__Group__1__Impl : ( ( rule__ReturnStatement__ExpressionAssignment_1 ) ) ;

+    public final void rule__ReturnStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14259:1: ( ( ( rule__ReturnStatement__ExpressionAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14260:1: ( ( rule__ReturnStatement__ExpressionAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14260:1: ( ( rule__ReturnStatement__ExpressionAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14261:1: ( rule__ReturnStatement__ExpressionAssignment_1 )

+            {

+             before(grammarAccess.getReturnStatementAccess().getExpressionAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14262:1: ( rule__ReturnStatement__ExpressionAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14262:2: rule__ReturnStatement__ExpressionAssignment_1

+            {

+            pushFollow(FOLLOW_rule__ReturnStatement__ExpressionAssignment_1_in_rule__ReturnStatement__Group__1__Impl29057);

+            rule__ReturnStatement__ExpressionAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getReturnStatementAccess().getExpressionAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ReturnStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ReturnStatement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14272:1: rule__ReturnStatement__Group__2 : rule__ReturnStatement__Group__2__Impl ;

+    public final void rule__ReturnStatement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14276:1: ( rule__ReturnStatement__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14277:2: rule__ReturnStatement__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__ReturnStatement__Group__2__Impl_in_rule__ReturnStatement__Group__229087);

+            rule__ReturnStatement__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ReturnStatement__Group__2"

+

+

+    // $ANTLR start "rule__ReturnStatement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14283:1: rule__ReturnStatement__Group__2__Impl : ( ';' ) ;

+    public final void rule__ReturnStatement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14287:1: ( ( ';' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14288:1: ( ';' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14288:1: ( ';' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14289:1: ';'

+            {

+             before(grammarAccess.getReturnStatementAccess().getSemicolonKeyword_2()); 

+            match(input,95,FOLLOW_95_in_rule__ReturnStatement__Group__2__Impl29115); 

+             after(grammarAccess.getReturnStatementAccess().getSemicolonKeyword_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ReturnStatement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__AcceptStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14308:1: rule__AcceptStatement__Group__0 : rule__AcceptStatement__Group__0__Impl rule__AcceptStatement__Group__1 ;

+    public final void rule__AcceptStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14312:1: ( rule__AcceptStatement__Group__0__Impl rule__AcceptStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14313:2: rule__AcceptStatement__Group__0__Impl rule__AcceptStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__AcceptStatement__Group__0__Impl_in_rule__AcceptStatement__Group__029152);

+            rule__AcceptStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AcceptStatement__Group__1_in_rule__AcceptStatement__Group__029155);

+            rule__AcceptStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptStatement__Group__0"

+

+

+    // $ANTLR start "rule__AcceptStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14320:1: rule__AcceptStatement__Group__0__Impl : ( ( rule__AcceptStatement__ClauseAssignment_0 ) ) ;

+    public final void rule__AcceptStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14324:1: ( ( ( rule__AcceptStatement__ClauseAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14325:1: ( ( rule__AcceptStatement__ClauseAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14325:1: ( ( rule__AcceptStatement__ClauseAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14326:1: ( rule__AcceptStatement__ClauseAssignment_0 )

+            {

+             before(grammarAccess.getAcceptStatementAccess().getClauseAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14327:1: ( rule__AcceptStatement__ClauseAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14327:2: rule__AcceptStatement__ClauseAssignment_0

+            {

+            pushFollow(FOLLOW_rule__AcceptStatement__ClauseAssignment_0_in_rule__AcceptStatement__Group__0__Impl29182);

+            rule__AcceptStatement__ClauseAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAcceptStatementAccess().getClauseAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__AcceptStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14337:1: rule__AcceptStatement__Group__1 : rule__AcceptStatement__Group__1__Impl ;

+    public final void rule__AcceptStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14341:1: ( rule__AcceptStatement__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14342:2: rule__AcceptStatement__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__AcceptStatement__Group__1__Impl_in_rule__AcceptStatement__Group__129212);

+            rule__AcceptStatement__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptStatement__Group__1"

+

+

+    // $ANTLR start "rule__AcceptStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14348:1: rule__AcceptStatement__Group__1__Impl : ( ( rule__AcceptStatement__Alternatives_1 ) ) ;

+    public final void rule__AcceptStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14352:1: ( ( ( rule__AcceptStatement__Alternatives_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14353:1: ( ( rule__AcceptStatement__Alternatives_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14353:1: ( ( rule__AcceptStatement__Alternatives_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14354:1: ( rule__AcceptStatement__Alternatives_1 )

+            {

+             before(grammarAccess.getAcceptStatementAccess().getAlternatives_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14355:1: ( rule__AcceptStatement__Alternatives_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14355:2: rule__AcceptStatement__Alternatives_1

+            {

+            pushFollow(FOLLOW_rule__AcceptStatement__Alternatives_1_in_rule__AcceptStatement__Group__1__Impl29239);

+            rule__AcceptStatement__Alternatives_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAcceptStatementAccess().getAlternatives_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__SimpleAcceptStatementCompletion__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14369:1: rule__SimpleAcceptStatementCompletion__Group__0 : rule__SimpleAcceptStatementCompletion__Group__0__Impl rule__SimpleAcceptStatementCompletion__Group__1 ;

+    public final void rule__SimpleAcceptStatementCompletion__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14373:1: ( rule__SimpleAcceptStatementCompletion__Group__0__Impl rule__SimpleAcceptStatementCompletion__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14374:2: rule__SimpleAcceptStatementCompletion__Group__0__Impl rule__SimpleAcceptStatementCompletion__Group__1

+            {

+            pushFollow(FOLLOW_rule__SimpleAcceptStatementCompletion__Group__0__Impl_in_rule__SimpleAcceptStatementCompletion__Group__029273);

+            rule__SimpleAcceptStatementCompletion__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SimpleAcceptStatementCompletion__Group__1_in_rule__SimpleAcceptStatementCompletion__Group__029276);

+            rule__SimpleAcceptStatementCompletion__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SimpleAcceptStatementCompletion__Group__0"

+

+

+    // $ANTLR start "rule__SimpleAcceptStatementCompletion__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14381:1: rule__SimpleAcceptStatementCompletion__Group__0__Impl : ( () ) ;

+    public final void rule__SimpleAcceptStatementCompletion__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14385:1: ( ( () ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14386:1: ( () )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14386:1: ( () )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14387:1: ()

+            {

+             before(grammarAccess.getSimpleAcceptStatementCompletionAccess().getSimpleAcceptStatementCompletionAction_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14388:1: ()

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14390:1: 

+            {

+            }

+

+             after(grammarAccess.getSimpleAcceptStatementCompletionAccess().getSimpleAcceptStatementCompletionAction_0()); 

+

+            }

+

+

+            }

+

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SimpleAcceptStatementCompletion__Group__0__Impl"

+

+

+    // $ANTLR start "rule__SimpleAcceptStatementCompletion__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14400:1: rule__SimpleAcceptStatementCompletion__Group__1 : rule__SimpleAcceptStatementCompletion__Group__1__Impl ;

+    public final void rule__SimpleAcceptStatementCompletion__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14404:1: ( rule__SimpleAcceptStatementCompletion__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14405:2: rule__SimpleAcceptStatementCompletion__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__SimpleAcceptStatementCompletion__Group__1__Impl_in_rule__SimpleAcceptStatementCompletion__Group__129334);

+            rule__SimpleAcceptStatementCompletion__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SimpleAcceptStatementCompletion__Group__1"

+

+

+    // $ANTLR start "rule__SimpleAcceptStatementCompletion__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14411:1: rule__SimpleAcceptStatementCompletion__Group__1__Impl : ( ';' ) ;

+    public final void rule__SimpleAcceptStatementCompletion__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14415:1: ( ( ';' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14416:1: ( ';' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14416:1: ( ';' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14417:1: ';'

+            {

+             before(grammarAccess.getSimpleAcceptStatementCompletionAccess().getSemicolonKeyword_1()); 

+            match(input,95,FOLLOW_95_in_rule__SimpleAcceptStatementCompletion__Group__1__Impl29362); 

+             after(grammarAccess.getSimpleAcceptStatementCompletionAccess().getSemicolonKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SimpleAcceptStatementCompletion__Group__1__Impl"

+

+

+    // $ANTLR start "rule__CompoundAcceptStatementCompletion__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14434:1: rule__CompoundAcceptStatementCompletion__Group__0 : rule__CompoundAcceptStatementCompletion__Group__0__Impl rule__CompoundAcceptStatementCompletion__Group__1 ;

+    public final void rule__CompoundAcceptStatementCompletion__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14438:1: ( rule__CompoundAcceptStatementCompletion__Group__0__Impl rule__CompoundAcceptStatementCompletion__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14439:2: rule__CompoundAcceptStatementCompletion__Group__0__Impl rule__CompoundAcceptStatementCompletion__Group__1

+            {

+            pushFollow(FOLLOW_rule__CompoundAcceptStatementCompletion__Group__0__Impl_in_rule__CompoundAcceptStatementCompletion__Group__029397);

+            rule__CompoundAcceptStatementCompletion__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__CompoundAcceptStatementCompletion__Group__1_in_rule__CompoundAcceptStatementCompletion__Group__029400);

+            rule__CompoundAcceptStatementCompletion__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CompoundAcceptStatementCompletion__Group__0"

+

+

+    // $ANTLR start "rule__CompoundAcceptStatementCompletion__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14446:1: rule__CompoundAcceptStatementCompletion__Group__0__Impl : ( ( rule__CompoundAcceptStatementCompletion__BlockAssignment_0 ) ) ;

+    public final void rule__CompoundAcceptStatementCompletion__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14450:1: ( ( ( rule__CompoundAcceptStatementCompletion__BlockAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14451:1: ( ( rule__CompoundAcceptStatementCompletion__BlockAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14451:1: ( ( rule__CompoundAcceptStatementCompletion__BlockAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14452:1: ( rule__CompoundAcceptStatementCompletion__BlockAssignment_0 )

+            {

+             before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14453:1: ( rule__CompoundAcceptStatementCompletion__BlockAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14453:2: rule__CompoundAcceptStatementCompletion__BlockAssignment_0

+            {

+            pushFollow(FOLLOW_rule__CompoundAcceptStatementCompletion__BlockAssignment_0_in_rule__CompoundAcceptStatementCompletion__Group__0__Impl29427);

+            rule__CompoundAcceptStatementCompletion__BlockAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CompoundAcceptStatementCompletion__Group__0__Impl"

+

+

+    // $ANTLR start "rule__CompoundAcceptStatementCompletion__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14463:1: rule__CompoundAcceptStatementCompletion__Group__1 : rule__CompoundAcceptStatementCompletion__Group__1__Impl ;

+    public final void rule__CompoundAcceptStatementCompletion__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14467:1: ( rule__CompoundAcceptStatementCompletion__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14468:2: rule__CompoundAcceptStatementCompletion__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__CompoundAcceptStatementCompletion__Group__1__Impl_in_rule__CompoundAcceptStatementCompletion__Group__129457);

+            rule__CompoundAcceptStatementCompletion__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CompoundAcceptStatementCompletion__Group__1"

+

+

+    // $ANTLR start "rule__CompoundAcceptStatementCompletion__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14474:1: rule__CompoundAcceptStatementCompletion__Group__1__Impl : ( ( rule__CompoundAcceptStatementCompletion__Group_1__0 )* ) ;

+    public final void rule__CompoundAcceptStatementCompletion__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14478:1: ( ( ( rule__CompoundAcceptStatementCompletion__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14479:1: ( ( rule__CompoundAcceptStatementCompletion__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14479:1: ( ( rule__CompoundAcceptStatementCompletion__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14480:1: ( rule__CompoundAcceptStatementCompletion__Group_1__0 )*

+            {

+             before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14481:1: ( rule__CompoundAcceptStatementCompletion__Group_1__0 )*

+            loop97:

+            do {

+                int alt97=2;

+                int LA97_0 = input.LA(1);

+

+                if ( (LA97_0==99) ) {

+                    alt97=1;

+                }

+

+

+                switch (alt97) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14481:2: rule__CompoundAcceptStatementCompletion__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__CompoundAcceptStatementCompletion__Group_1__0_in_rule__CompoundAcceptStatementCompletion__Group__1__Impl29484);

+            	    rule__CompoundAcceptStatementCompletion__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop97;

+                }

+            } while (true);

+

+             after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CompoundAcceptStatementCompletion__Group__1__Impl"

+

+

+    // $ANTLR start "rule__CompoundAcceptStatementCompletion__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14495:1: rule__CompoundAcceptStatementCompletion__Group_1__0 : rule__CompoundAcceptStatementCompletion__Group_1__0__Impl rule__CompoundAcceptStatementCompletion__Group_1__1 ;

+    public final void rule__CompoundAcceptStatementCompletion__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14499:1: ( rule__CompoundAcceptStatementCompletion__Group_1__0__Impl rule__CompoundAcceptStatementCompletion__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14500:2: rule__CompoundAcceptStatementCompletion__Group_1__0__Impl rule__CompoundAcceptStatementCompletion__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__CompoundAcceptStatementCompletion__Group_1__0__Impl_in_rule__CompoundAcceptStatementCompletion__Group_1__029519);

+            rule__CompoundAcceptStatementCompletion__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__CompoundAcceptStatementCompletion__Group_1__1_in_rule__CompoundAcceptStatementCompletion__Group_1__029522);

+            rule__CompoundAcceptStatementCompletion__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CompoundAcceptStatementCompletion__Group_1__0"

+

+

+    // $ANTLR start "rule__CompoundAcceptStatementCompletion__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14507:1: rule__CompoundAcceptStatementCompletion__Group_1__0__Impl : ( 'or' ) ;

+    public final void rule__CompoundAcceptStatementCompletion__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14511:1: ( ( 'or' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14512:1: ( 'or' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14512:1: ( 'or' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14513:1: 'or'

+            {

+             before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getOrKeyword_1_0()); 

+            match(input,99,FOLLOW_99_in_rule__CompoundAcceptStatementCompletion__Group_1__0__Impl29550); 

+             after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getOrKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CompoundAcceptStatementCompletion__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__CompoundAcceptStatementCompletion__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14526:1: rule__CompoundAcceptStatementCompletion__Group_1__1 : rule__CompoundAcceptStatementCompletion__Group_1__1__Impl ;

+    public final void rule__CompoundAcceptStatementCompletion__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14530:1: ( rule__CompoundAcceptStatementCompletion__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14531:2: rule__CompoundAcceptStatementCompletion__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__CompoundAcceptStatementCompletion__Group_1__1__Impl_in_rule__CompoundAcceptStatementCompletion__Group_1__129581);

+            rule__CompoundAcceptStatementCompletion__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CompoundAcceptStatementCompletion__Group_1__1"

+

+

+    // $ANTLR start "rule__CompoundAcceptStatementCompletion__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14537:1: rule__CompoundAcceptStatementCompletion__Group_1__1__Impl : ( ( rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1 ) ) ;

+    public final void rule__CompoundAcceptStatementCompletion__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14541:1: ( ( ( rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14542:1: ( ( rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14542:1: ( ( rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14543:1: ( rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1 )

+            {

+             before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14544:1: ( rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14544:2: rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1_in_rule__CompoundAcceptStatementCompletion__Group_1__1__Impl29608);

+            rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CompoundAcceptStatementCompletion__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__AcceptBlock__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14558:1: rule__AcceptBlock__Group__0 : rule__AcceptBlock__Group__0__Impl rule__AcceptBlock__Group__1 ;

+    public final void rule__AcceptBlock__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14562:1: ( rule__AcceptBlock__Group__0__Impl rule__AcceptBlock__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14563:2: rule__AcceptBlock__Group__0__Impl rule__AcceptBlock__Group__1

+            {

+            pushFollow(FOLLOW_rule__AcceptBlock__Group__0__Impl_in_rule__AcceptBlock__Group__029642);

+            rule__AcceptBlock__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AcceptBlock__Group__1_in_rule__AcceptBlock__Group__029645);

+            rule__AcceptBlock__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptBlock__Group__0"

+

+

+    // $ANTLR start "rule__AcceptBlock__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14570:1: rule__AcceptBlock__Group__0__Impl : ( ( rule__AcceptBlock__ClauseAssignment_0 ) ) ;

+    public final void rule__AcceptBlock__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14574:1: ( ( ( rule__AcceptBlock__ClauseAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14575:1: ( ( rule__AcceptBlock__ClauseAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14575:1: ( ( rule__AcceptBlock__ClauseAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14576:1: ( rule__AcceptBlock__ClauseAssignment_0 )

+            {

+             before(grammarAccess.getAcceptBlockAccess().getClauseAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14577:1: ( rule__AcceptBlock__ClauseAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14577:2: rule__AcceptBlock__ClauseAssignment_0

+            {

+            pushFollow(FOLLOW_rule__AcceptBlock__ClauseAssignment_0_in_rule__AcceptBlock__Group__0__Impl29672);

+            rule__AcceptBlock__ClauseAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAcceptBlockAccess().getClauseAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptBlock__Group__0__Impl"

+

+

+    // $ANTLR start "rule__AcceptBlock__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14587:1: rule__AcceptBlock__Group__1 : rule__AcceptBlock__Group__1__Impl ;

+    public final void rule__AcceptBlock__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14591:1: ( rule__AcceptBlock__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14592:2: rule__AcceptBlock__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__AcceptBlock__Group__1__Impl_in_rule__AcceptBlock__Group__129702);

+            rule__AcceptBlock__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptBlock__Group__1"

+

+

+    // $ANTLR start "rule__AcceptBlock__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14598:1: rule__AcceptBlock__Group__1__Impl : ( ( rule__AcceptBlock__BlockAssignment_1 ) ) ;

+    public final void rule__AcceptBlock__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14602:1: ( ( ( rule__AcceptBlock__BlockAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14603:1: ( ( rule__AcceptBlock__BlockAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14603:1: ( ( rule__AcceptBlock__BlockAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14604:1: ( rule__AcceptBlock__BlockAssignment_1 )

+            {

+             before(grammarAccess.getAcceptBlockAccess().getBlockAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14605:1: ( rule__AcceptBlock__BlockAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14605:2: rule__AcceptBlock__BlockAssignment_1

+            {

+            pushFollow(FOLLOW_rule__AcceptBlock__BlockAssignment_1_in_rule__AcceptBlock__Group__1__Impl29729);

+            rule__AcceptBlock__BlockAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAcceptBlockAccess().getBlockAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptBlock__Group__1__Impl"

+

+

+    // $ANTLR start "rule__AcceptClause__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14619:1: rule__AcceptClause__Group__0 : rule__AcceptClause__Group__0__Impl rule__AcceptClause__Group__1 ;

+    public final void rule__AcceptClause__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14623:1: ( rule__AcceptClause__Group__0__Impl rule__AcceptClause__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14624:2: rule__AcceptClause__Group__0__Impl rule__AcceptClause__Group__1

+            {

+            pushFollow(FOLLOW_rule__AcceptClause__Group__0__Impl_in_rule__AcceptClause__Group__029763);

+            rule__AcceptClause__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AcceptClause__Group__1_in_rule__AcceptClause__Group__029766);

+            rule__AcceptClause__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group__0"

+

+

+    // $ANTLR start "rule__AcceptClause__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14631:1: rule__AcceptClause__Group__0__Impl : ( 'accept' ) ;

+    public final void rule__AcceptClause__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14635:1: ( ( 'accept' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14636:1: ( 'accept' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14636:1: ( 'accept' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14637:1: 'accept'

+            {

+             before(grammarAccess.getAcceptClauseAccess().getAcceptKeyword_0()); 

+            match(input,109,FOLLOW_109_in_rule__AcceptClause__Group__0__Impl29794); 

+             after(grammarAccess.getAcceptClauseAccess().getAcceptKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group__0__Impl"

+

+

+    // $ANTLR start "rule__AcceptClause__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14650:1: rule__AcceptClause__Group__1 : rule__AcceptClause__Group__1__Impl rule__AcceptClause__Group__2 ;

+    public final void rule__AcceptClause__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14654:1: ( rule__AcceptClause__Group__1__Impl rule__AcceptClause__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14655:2: rule__AcceptClause__Group__1__Impl rule__AcceptClause__Group__2

+            {

+            pushFollow(FOLLOW_rule__AcceptClause__Group__1__Impl_in_rule__AcceptClause__Group__129825);

+            rule__AcceptClause__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AcceptClause__Group__2_in_rule__AcceptClause__Group__129828);

+            rule__AcceptClause__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group__1"

+

+

+    // $ANTLR start "rule__AcceptClause__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14662:1: rule__AcceptClause__Group__1__Impl : ( '(' ) ;

+    public final void rule__AcceptClause__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14666:1: ( ( '(' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14667:1: ( '(' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14667:1: ( '(' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14668:1: '('

+            {

+             before(grammarAccess.getAcceptClauseAccess().getLeftParenthesisKeyword_1()); 

+            match(input,68,FOLLOW_68_in_rule__AcceptClause__Group__1__Impl29856); 

+             after(grammarAccess.getAcceptClauseAccess().getLeftParenthesisKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group__1__Impl"

+

+

+    // $ANTLR start "rule__AcceptClause__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14681:1: rule__AcceptClause__Group__2 : rule__AcceptClause__Group__2__Impl rule__AcceptClause__Group__3 ;

+    public final void rule__AcceptClause__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14685:1: ( rule__AcceptClause__Group__2__Impl rule__AcceptClause__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14686:2: rule__AcceptClause__Group__2__Impl rule__AcceptClause__Group__3

+            {

+            pushFollow(FOLLOW_rule__AcceptClause__Group__2__Impl_in_rule__AcceptClause__Group__229887);

+            rule__AcceptClause__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AcceptClause__Group__3_in_rule__AcceptClause__Group__229890);

+            rule__AcceptClause__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group__2"

+

+

+    // $ANTLR start "rule__AcceptClause__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14693:1: rule__AcceptClause__Group__2__Impl : ( ( rule__AcceptClause__Group_2__0 )? ) ;

+    public final void rule__AcceptClause__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14697:1: ( ( ( rule__AcceptClause__Group_2__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14698:1: ( ( rule__AcceptClause__Group_2__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14698:1: ( ( rule__AcceptClause__Group_2__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14699:1: ( rule__AcceptClause__Group_2__0 )?

+            {

+             before(grammarAccess.getAcceptClauseAccess().getGroup_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14700:1: ( rule__AcceptClause__Group_2__0 )?

+            int alt98=2;

+            int LA98_0 = input.LA(1);

+

+            if ( (LA98_0==RULE_ID) ) {

+                int LA98_1 = input.LA(2);

+

+                if ( (LA98_1==71) ) {

+                    alt98=1;

+                }

+            }

+            switch (alt98) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14700:2: rule__AcceptClause__Group_2__0

+                    {

+                    pushFollow(FOLLOW_rule__AcceptClause__Group_2__0_in_rule__AcceptClause__Group__2__Impl29917);

+                    rule__AcceptClause__Group_2__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getAcceptClauseAccess().getGroup_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group__2__Impl"

+

+

+    // $ANTLR start "rule__AcceptClause__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14710:1: rule__AcceptClause__Group__3 : rule__AcceptClause__Group__3__Impl rule__AcceptClause__Group__4 ;

+    public final void rule__AcceptClause__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14714:1: ( rule__AcceptClause__Group__3__Impl rule__AcceptClause__Group__4 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14715:2: rule__AcceptClause__Group__3__Impl rule__AcceptClause__Group__4

+            {

+            pushFollow(FOLLOW_rule__AcceptClause__Group__3__Impl_in_rule__AcceptClause__Group__329948);

+            rule__AcceptClause__Group__3__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AcceptClause__Group__4_in_rule__AcceptClause__Group__329951);

+            rule__AcceptClause__Group__4();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group__3"

+

+

+    // $ANTLR start "rule__AcceptClause__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14722:1: rule__AcceptClause__Group__3__Impl : ( ( rule__AcceptClause__QualifiedNameListAssignment_3 ) ) ;

+    public final void rule__AcceptClause__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14726:1: ( ( ( rule__AcceptClause__QualifiedNameListAssignment_3 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14727:1: ( ( rule__AcceptClause__QualifiedNameListAssignment_3 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14727:1: ( ( rule__AcceptClause__QualifiedNameListAssignment_3 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14728:1: ( rule__AcceptClause__QualifiedNameListAssignment_3 )

+            {

+             before(grammarAccess.getAcceptClauseAccess().getQualifiedNameListAssignment_3()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14729:1: ( rule__AcceptClause__QualifiedNameListAssignment_3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14729:2: rule__AcceptClause__QualifiedNameListAssignment_3

+            {

+            pushFollow(FOLLOW_rule__AcceptClause__QualifiedNameListAssignment_3_in_rule__AcceptClause__Group__3__Impl29978);

+            rule__AcceptClause__QualifiedNameListAssignment_3();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAcceptClauseAccess().getQualifiedNameListAssignment_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group__3__Impl"

+

+

+    // $ANTLR start "rule__AcceptClause__Group__4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14739:1: rule__AcceptClause__Group__4 : rule__AcceptClause__Group__4__Impl ;

+    public final void rule__AcceptClause__Group__4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14743:1: ( rule__AcceptClause__Group__4__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14744:2: rule__AcceptClause__Group__4__Impl

+            {

+            pushFollow(FOLLOW_rule__AcceptClause__Group__4__Impl_in_rule__AcceptClause__Group__430008);

+            rule__AcceptClause__Group__4__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group__4"

+

+

+    // $ANTLR start "rule__AcceptClause__Group__4__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14750:1: rule__AcceptClause__Group__4__Impl : ( ')' ) ;

+    public final void rule__AcceptClause__Group__4__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14754:1: ( ( ')' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14755:1: ( ')' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14755:1: ( ')' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14756:1: ')'

+            {

+             before(grammarAccess.getAcceptClauseAccess().getRightParenthesisKeyword_4()); 

+            match(input,69,FOLLOW_69_in_rule__AcceptClause__Group__4__Impl30036); 

+             after(grammarAccess.getAcceptClauseAccess().getRightParenthesisKeyword_4()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group__4__Impl"

+

+

+    // $ANTLR start "rule__AcceptClause__Group_2__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14779:1: rule__AcceptClause__Group_2__0 : rule__AcceptClause__Group_2__0__Impl rule__AcceptClause__Group_2__1 ;

+    public final void rule__AcceptClause__Group_2__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14783:1: ( rule__AcceptClause__Group_2__0__Impl rule__AcceptClause__Group_2__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14784:2: rule__AcceptClause__Group_2__0__Impl rule__AcceptClause__Group_2__1

+            {

+            pushFollow(FOLLOW_rule__AcceptClause__Group_2__0__Impl_in_rule__AcceptClause__Group_2__030077);

+            rule__AcceptClause__Group_2__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AcceptClause__Group_2__1_in_rule__AcceptClause__Group_2__030080);

+            rule__AcceptClause__Group_2__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group_2__0"

+

+

+    // $ANTLR start "rule__AcceptClause__Group_2__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14791:1: rule__AcceptClause__Group_2__0__Impl : ( ( rule__AcceptClause__NameAssignment_2_0 ) ) ;

+    public final void rule__AcceptClause__Group_2__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14795:1: ( ( ( rule__AcceptClause__NameAssignment_2_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14796:1: ( ( rule__AcceptClause__NameAssignment_2_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14796:1: ( ( rule__AcceptClause__NameAssignment_2_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14797:1: ( rule__AcceptClause__NameAssignment_2_0 )

+            {

+             before(grammarAccess.getAcceptClauseAccess().getNameAssignment_2_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14798:1: ( rule__AcceptClause__NameAssignment_2_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14798:2: rule__AcceptClause__NameAssignment_2_0

+            {

+            pushFollow(FOLLOW_rule__AcceptClause__NameAssignment_2_0_in_rule__AcceptClause__Group_2__0__Impl30107);

+            rule__AcceptClause__NameAssignment_2_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAcceptClauseAccess().getNameAssignment_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group_2__0__Impl"

+

+

+    // $ANTLR start "rule__AcceptClause__Group_2__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14808:1: rule__AcceptClause__Group_2__1 : rule__AcceptClause__Group_2__1__Impl ;

+    public final void rule__AcceptClause__Group_2__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14812:1: ( rule__AcceptClause__Group_2__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14813:2: rule__AcceptClause__Group_2__1__Impl

+            {

+            pushFollow(FOLLOW_rule__AcceptClause__Group_2__1__Impl_in_rule__AcceptClause__Group_2__130137);

+            rule__AcceptClause__Group_2__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group_2__1"

+

+

+    // $ANTLR start "rule__AcceptClause__Group_2__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14819:1: rule__AcceptClause__Group_2__1__Impl : ( ':' ) ;

+    public final void rule__AcceptClause__Group_2__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14823:1: ( ( ':' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14824:1: ( ':' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14824:1: ( ':' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14825:1: ':'

+            {

+             before(grammarAccess.getAcceptClauseAccess().getColonKeyword_2_1()); 

+            match(input,71,FOLLOW_71_in_rule__AcceptClause__Group_2__1__Impl30165); 

+             after(grammarAccess.getAcceptClauseAccess().getColonKeyword_2_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__Group_2__1__Impl"

+

+

+    // $ANTLR start "rule__ClassifyStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14842:1: rule__ClassifyStatement__Group__0 : rule__ClassifyStatement__Group__0__Impl rule__ClassifyStatement__Group__1 ;

+    public final void rule__ClassifyStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14846:1: ( rule__ClassifyStatement__Group__0__Impl rule__ClassifyStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14847:2: rule__ClassifyStatement__Group__0__Impl rule__ClassifyStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__ClassifyStatement__Group__0__Impl_in_rule__ClassifyStatement__Group__030200);

+            rule__ClassifyStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ClassifyStatement__Group__1_in_rule__ClassifyStatement__Group__030203);

+            rule__ClassifyStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassifyStatement__Group__0"

+

+

+    // $ANTLR start "rule__ClassifyStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14854:1: rule__ClassifyStatement__Group__0__Impl : ( 'classify' ) ;

+    public final void rule__ClassifyStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14858:1: ( ( 'classify' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14859:1: ( 'classify' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14859:1: ( 'classify' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14860:1: 'classify'

+            {

+             before(grammarAccess.getClassifyStatementAccess().getClassifyKeyword_0()); 

+            match(input,110,FOLLOW_110_in_rule__ClassifyStatement__Group__0__Impl30231); 

+             after(grammarAccess.getClassifyStatementAccess().getClassifyKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassifyStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ClassifyStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14873:1: rule__ClassifyStatement__Group__1 : rule__ClassifyStatement__Group__1__Impl rule__ClassifyStatement__Group__2 ;

+    public final void rule__ClassifyStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14877:1: ( rule__ClassifyStatement__Group__1__Impl rule__ClassifyStatement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14878:2: rule__ClassifyStatement__Group__1__Impl rule__ClassifyStatement__Group__2

+            {

+            pushFollow(FOLLOW_rule__ClassifyStatement__Group__1__Impl_in_rule__ClassifyStatement__Group__130262);

+            rule__ClassifyStatement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ClassifyStatement__Group__2_in_rule__ClassifyStatement__Group__130265);

+            rule__ClassifyStatement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassifyStatement__Group__1"

+

+

+    // $ANTLR start "rule__ClassifyStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14885:1: rule__ClassifyStatement__Group__1__Impl : ( ( rule__ClassifyStatement__ExpressionAssignment_1 ) ) ;

+    public final void rule__ClassifyStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14889:1: ( ( ( rule__ClassifyStatement__ExpressionAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14890:1: ( ( rule__ClassifyStatement__ExpressionAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14890:1: ( ( rule__ClassifyStatement__ExpressionAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14891:1: ( rule__ClassifyStatement__ExpressionAssignment_1 )

+            {

+             before(grammarAccess.getClassifyStatementAccess().getExpressionAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14892:1: ( rule__ClassifyStatement__ExpressionAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14892:2: rule__ClassifyStatement__ExpressionAssignment_1

+            {

+            pushFollow(FOLLOW_rule__ClassifyStatement__ExpressionAssignment_1_in_rule__ClassifyStatement__Group__1__Impl30292);

+            rule__ClassifyStatement__ExpressionAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassifyStatementAccess().getExpressionAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassifyStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ClassifyStatement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14902:1: rule__ClassifyStatement__Group__2 : rule__ClassifyStatement__Group__2__Impl rule__ClassifyStatement__Group__3 ;

+    public final void rule__ClassifyStatement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14906:1: ( rule__ClassifyStatement__Group__2__Impl rule__ClassifyStatement__Group__3 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14907:2: rule__ClassifyStatement__Group__2__Impl rule__ClassifyStatement__Group__3

+            {

+            pushFollow(FOLLOW_rule__ClassifyStatement__Group__2__Impl_in_rule__ClassifyStatement__Group__230322);

+            rule__ClassifyStatement__Group__2__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ClassifyStatement__Group__3_in_rule__ClassifyStatement__Group__230325);

+            rule__ClassifyStatement__Group__3();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassifyStatement__Group__2"

+

+

+    // $ANTLR start "rule__ClassifyStatement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14914:1: rule__ClassifyStatement__Group__2__Impl : ( ( rule__ClassifyStatement__ClauseAssignment_2 ) ) ;

+    public final void rule__ClassifyStatement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14918:1: ( ( ( rule__ClassifyStatement__ClauseAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14919:1: ( ( rule__ClassifyStatement__ClauseAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14919:1: ( ( rule__ClassifyStatement__ClauseAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14920:1: ( rule__ClassifyStatement__ClauseAssignment_2 )

+            {

+             before(grammarAccess.getClassifyStatementAccess().getClauseAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14921:1: ( rule__ClassifyStatement__ClauseAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14921:2: rule__ClassifyStatement__ClauseAssignment_2

+            {

+            pushFollow(FOLLOW_rule__ClassifyStatement__ClauseAssignment_2_in_rule__ClassifyStatement__Group__2__Impl30352);

+            rule__ClassifyStatement__ClauseAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassifyStatementAccess().getClauseAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassifyStatement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__ClassifyStatement__Group__3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14931:1: rule__ClassifyStatement__Group__3 : rule__ClassifyStatement__Group__3__Impl ;

+    public final void rule__ClassifyStatement__Group__3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14935:1: ( rule__ClassifyStatement__Group__3__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14936:2: rule__ClassifyStatement__Group__3__Impl

+            {

+            pushFollow(FOLLOW_rule__ClassifyStatement__Group__3__Impl_in_rule__ClassifyStatement__Group__330382);

+            rule__ClassifyStatement__Group__3__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassifyStatement__Group__3"

+

+

+    // $ANTLR start "rule__ClassifyStatement__Group__3__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14942:1: rule__ClassifyStatement__Group__3__Impl : ( ';' ) ;

+    public final void rule__ClassifyStatement__Group__3__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14946:1: ( ( ';' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14947:1: ( ';' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14947:1: ( ';' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14948:1: ';'

+            {

+             before(grammarAccess.getClassifyStatementAccess().getSemicolonKeyword_3()); 

+            match(input,95,FOLLOW_95_in_rule__ClassifyStatement__Group__3__Impl30410); 

+             after(grammarAccess.getClassifyStatementAccess().getSemicolonKeyword_3()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassifyStatement__Group__3__Impl"

+

+

+    // $ANTLR start "rule__ClassificationClause__Group_0__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14969:1: rule__ClassificationClause__Group_0__0 : rule__ClassificationClause__Group_0__0__Impl rule__ClassificationClause__Group_0__1 ;

+    public final void rule__ClassificationClause__Group_0__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14973:1: ( rule__ClassificationClause__Group_0__0__Impl rule__ClassificationClause__Group_0__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14974:2: rule__ClassificationClause__Group_0__0__Impl rule__ClassificationClause__Group_0__1

+            {

+            pushFollow(FOLLOW_rule__ClassificationClause__Group_0__0__Impl_in_rule__ClassificationClause__Group_0__030449);

+            rule__ClassificationClause__Group_0__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ClassificationClause__Group_0__1_in_rule__ClassificationClause__Group_0__030452);

+            rule__ClassificationClause__Group_0__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationClause__Group_0__0"

+

+

+    // $ANTLR start "rule__ClassificationClause__Group_0__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14981:1: rule__ClassificationClause__Group_0__0__Impl : ( ( rule__ClassificationClause__ClassifyFromClauseAssignment_0_0 ) ) ;

+    public final void rule__ClassificationClause__Group_0__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14985:1: ( ( ( rule__ClassificationClause__ClassifyFromClauseAssignment_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14986:1: ( ( rule__ClassificationClause__ClassifyFromClauseAssignment_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14986:1: ( ( rule__ClassificationClause__ClassifyFromClauseAssignment_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14987:1: ( rule__ClassificationClause__ClassifyFromClauseAssignment_0_0 )

+            {

+             before(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseAssignment_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14988:1: ( rule__ClassificationClause__ClassifyFromClauseAssignment_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14988:2: rule__ClassificationClause__ClassifyFromClauseAssignment_0_0

+            {

+            pushFollow(FOLLOW_rule__ClassificationClause__ClassifyFromClauseAssignment_0_0_in_rule__ClassificationClause__Group_0__0__Impl30479);

+            rule__ClassificationClause__ClassifyFromClauseAssignment_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseAssignment_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationClause__Group_0__0__Impl"

+

+

+    // $ANTLR start "rule__ClassificationClause__Group_0__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:14998:1: rule__ClassificationClause__Group_0__1 : rule__ClassificationClause__Group_0__1__Impl ;

+    public final void rule__ClassificationClause__Group_0__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15002:1: ( rule__ClassificationClause__Group_0__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15003:2: rule__ClassificationClause__Group_0__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ClassificationClause__Group_0__1__Impl_in_rule__ClassificationClause__Group_0__130509);

+            rule__ClassificationClause__Group_0__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationClause__Group_0__1"

+

+

+    // $ANTLR start "rule__ClassificationClause__Group_0__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15009:1: rule__ClassificationClause__Group_0__1__Impl : ( ( rule__ClassificationClause__ClassifyToClauseAssignment_0_1 )? ) ;

+    public final void rule__ClassificationClause__Group_0__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15013:1: ( ( ( rule__ClassificationClause__ClassifyToClauseAssignment_0_1 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15014:1: ( ( rule__ClassificationClause__ClassifyToClauseAssignment_0_1 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15014:1: ( ( rule__ClassificationClause__ClassifyToClauseAssignment_0_1 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15015:1: ( rule__ClassificationClause__ClassifyToClauseAssignment_0_1 )?

+            {

+             before(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_0_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15016:1: ( rule__ClassificationClause__ClassifyToClauseAssignment_0_1 )?

+            int alt99=2;

+            int LA99_0 = input.LA(1);

+

+            if ( (LA99_0==112) ) {

+                alt99=1;

+            }

+            switch (alt99) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15016:2: rule__ClassificationClause__ClassifyToClauseAssignment_0_1

+                    {

+                    pushFollow(FOLLOW_rule__ClassificationClause__ClassifyToClauseAssignment_0_1_in_rule__ClassificationClause__Group_0__1__Impl30536);

+                    rule__ClassificationClause__ClassifyToClauseAssignment_0_1();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_0_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationClause__Group_0__1__Impl"

+

+

+    // $ANTLR start "rule__ClassificationClause__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15030:1: rule__ClassificationClause__Group_1__0 : rule__ClassificationClause__Group_1__0__Impl rule__ClassificationClause__Group_1__1 ;

+    public final void rule__ClassificationClause__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15034:1: ( rule__ClassificationClause__Group_1__0__Impl rule__ClassificationClause__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15035:2: rule__ClassificationClause__Group_1__0__Impl rule__ClassificationClause__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__ClassificationClause__Group_1__0__Impl_in_rule__ClassificationClause__Group_1__030571);

+            rule__ClassificationClause__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ClassificationClause__Group_1__1_in_rule__ClassificationClause__Group_1__030574);

+            rule__ClassificationClause__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationClause__Group_1__0"

+

+

+    // $ANTLR start "rule__ClassificationClause__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15042:1: rule__ClassificationClause__Group_1__0__Impl : ( ( rule__ClassificationClause__ReclassyAllClauseAssignment_1_0 )? ) ;

+    public final void rule__ClassificationClause__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15046:1: ( ( ( rule__ClassificationClause__ReclassyAllClauseAssignment_1_0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15047:1: ( ( rule__ClassificationClause__ReclassyAllClauseAssignment_1_0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15047:1: ( ( rule__ClassificationClause__ReclassyAllClauseAssignment_1_0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15048:1: ( rule__ClassificationClause__ReclassyAllClauseAssignment_1_0 )?

+            {

+             before(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseAssignment_1_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15049:1: ( rule__ClassificationClause__ReclassyAllClauseAssignment_1_0 )?

+            int alt100=2;

+            int LA100_0 = input.LA(1);

+

+            if ( (LA100_0==111) ) {

+                alt100=1;

+            }

+            switch (alt100) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15049:2: rule__ClassificationClause__ReclassyAllClauseAssignment_1_0

+                    {

+                    pushFollow(FOLLOW_rule__ClassificationClause__ReclassyAllClauseAssignment_1_0_in_rule__ClassificationClause__Group_1__0__Impl30601);

+                    rule__ClassificationClause__ReclassyAllClauseAssignment_1_0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseAssignment_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationClause__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__ClassificationClause__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15059:1: rule__ClassificationClause__Group_1__1 : rule__ClassificationClause__Group_1__1__Impl ;

+    public final void rule__ClassificationClause__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15063:1: ( rule__ClassificationClause__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15064:2: rule__ClassificationClause__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ClassificationClause__Group_1__1__Impl_in_rule__ClassificationClause__Group_1__130632);

+            rule__ClassificationClause__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationClause__Group_1__1"

+

+

+    // $ANTLR start "rule__ClassificationClause__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15070:1: rule__ClassificationClause__Group_1__1__Impl : ( ( rule__ClassificationClause__ClassifyToClauseAssignment_1_1 ) ) ;

+    public final void rule__ClassificationClause__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15074:1: ( ( ( rule__ClassificationClause__ClassifyToClauseAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15075:1: ( ( rule__ClassificationClause__ClassifyToClauseAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15075:1: ( ( rule__ClassificationClause__ClassifyToClauseAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15076:1: ( rule__ClassificationClause__ClassifyToClauseAssignment_1_1 )

+            {

+             before(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15077:1: ( rule__ClassificationClause__ClassifyToClauseAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15077:2: rule__ClassificationClause__ClassifyToClauseAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__ClassificationClause__ClassifyToClauseAssignment_1_1_in_rule__ClassificationClause__Group_1__1__Impl30659);

+            rule__ClassificationClause__ClassifyToClauseAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassificationClauseAccess().getClassifyToClauseAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationClause__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__ClassificationFromClause__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15091:1: rule__ClassificationFromClause__Group__0 : rule__ClassificationFromClause__Group__0__Impl rule__ClassificationFromClause__Group__1 ;

+    public final void rule__ClassificationFromClause__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15095:1: ( rule__ClassificationFromClause__Group__0__Impl rule__ClassificationFromClause__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15096:2: rule__ClassificationFromClause__Group__0__Impl rule__ClassificationFromClause__Group__1

+            {

+            pushFollow(FOLLOW_rule__ClassificationFromClause__Group__0__Impl_in_rule__ClassificationFromClause__Group__030693);

+            rule__ClassificationFromClause__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ClassificationFromClause__Group__1_in_rule__ClassificationFromClause__Group__030696);

+            rule__ClassificationFromClause__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationFromClause__Group__0"

+

+

+    // $ANTLR start "rule__ClassificationFromClause__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15103:1: rule__ClassificationFromClause__Group__0__Impl : ( 'from' ) ;

+    public final void rule__ClassificationFromClause__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15107:1: ( ( 'from' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15108:1: ( 'from' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15108:1: ( 'from' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15109:1: 'from'

+            {

+             before(grammarAccess.getClassificationFromClauseAccess().getFromKeyword_0()); 

+            match(input,111,FOLLOW_111_in_rule__ClassificationFromClause__Group__0__Impl30724); 

+             after(grammarAccess.getClassificationFromClauseAccess().getFromKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationFromClause__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ClassificationFromClause__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15122:1: rule__ClassificationFromClause__Group__1 : rule__ClassificationFromClause__Group__1__Impl ;

+    public final void rule__ClassificationFromClause__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15126:1: ( rule__ClassificationFromClause__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15127:2: rule__ClassificationFromClause__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ClassificationFromClause__Group__1__Impl_in_rule__ClassificationFromClause__Group__130755);

+            rule__ClassificationFromClause__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationFromClause__Group__1"

+

+

+    // $ANTLR start "rule__ClassificationFromClause__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15133:1: rule__ClassificationFromClause__Group__1__Impl : ( ( rule__ClassificationFromClause__QualifiedNameListAssignment_1 ) ) ;

+    public final void rule__ClassificationFromClause__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15137:1: ( ( ( rule__ClassificationFromClause__QualifiedNameListAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15138:1: ( ( rule__ClassificationFromClause__QualifiedNameListAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15138:1: ( ( rule__ClassificationFromClause__QualifiedNameListAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15139:1: ( rule__ClassificationFromClause__QualifiedNameListAssignment_1 )

+            {

+             before(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15140:1: ( rule__ClassificationFromClause__QualifiedNameListAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15140:2: rule__ClassificationFromClause__QualifiedNameListAssignment_1

+            {

+            pushFollow(FOLLOW_rule__ClassificationFromClause__QualifiedNameListAssignment_1_in_rule__ClassificationFromClause__Group__1__Impl30782);

+            rule__ClassificationFromClause__QualifiedNameListAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationFromClause__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ClassificationToClause__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15154:1: rule__ClassificationToClause__Group__0 : rule__ClassificationToClause__Group__0__Impl rule__ClassificationToClause__Group__1 ;

+    public final void rule__ClassificationToClause__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15158:1: ( rule__ClassificationToClause__Group__0__Impl rule__ClassificationToClause__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15159:2: rule__ClassificationToClause__Group__0__Impl rule__ClassificationToClause__Group__1

+            {

+            pushFollow(FOLLOW_rule__ClassificationToClause__Group__0__Impl_in_rule__ClassificationToClause__Group__030816);

+            rule__ClassificationToClause__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ClassificationToClause__Group__1_in_rule__ClassificationToClause__Group__030819);

+            rule__ClassificationToClause__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationToClause__Group__0"

+

+

+    // $ANTLR start "rule__ClassificationToClause__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15166:1: rule__ClassificationToClause__Group__0__Impl : ( 'to' ) ;

+    public final void rule__ClassificationToClause__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15170:1: ( ( 'to' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15171:1: ( 'to' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15171:1: ( 'to' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15172:1: 'to'

+            {

+             before(grammarAccess.getClassificationToClauseAccess().getToKeyword_0()); 

+            match(input,112,FOLLOW_112_in_rule__ClassificationToClause__Group__0__Impl30847); 

+             after(grammarAccess.getClassificationToClauseAccess().getToKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationToClause__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ClassificationToClause__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15185:1: rule__ClassificationToClause__Group__1 : rule__ClassificationToClause__Group__1__Impl ;

+    public final void rule__ClassificationToClause__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15189:1: ( rule__ClassificationToClause__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15190:2: rule__ClassificationToClause__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__ClassificationToClause__Group__1__Impl_in_rule__ClassificationToClause__Group__130878);

+            rule__ClassificationToClause__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationToClause__Group__1"

+

+

+    // $ANTLR start "rule__ClassificationToClause__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15196:1: rule__ClassificationToClause__Group__1__Impl : ( ( rule__ClassificationToClause__QualifiedNameListAssignment_1 ) ) ;

+    public final void rule__ClassificationToClause__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15200:1: ( ( ( rule__ClassificationToClause__QualifiedNameListAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15201:1: ( ( rule__ClassificationToClause__QualifiedNameListAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15201:1: ( ( rule__ClassificationToClause__QualifiedNameListAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15202:1: ( rule__ClassificationToClause__QualifiedNameListAssignment_1 )

+            {

+             before(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15203:1: ( rule__ClassificationToClause__QualifiedNameListAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15203:2: rule__ClassificationToClause__QualifiedNameListAssignment_1

+            {

+            pushFollow(FOLLOW_rule__ClassificationToClause__QualifiedNameListAssignment_1_in_rule__ClassificationToClause__Group__1__Impl30905);

+            rule__ClassificationToClause__QualifiedNameListAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationToClause__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ReclassifyAllClause__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15217:1: rule__ReclassifyAllClause__Group__0 : rule__ReclassifyAllClause__Group__0__Impl rule__ReclassifyAllClause__Group__1 ;

+    public final void rule__ReclassifyAllClause__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15221:1: ( rule__ReclassifyAllClause__Group__0__Impl rule__ReclassifyAllClause__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15222:2: rule__ReclassifyAllClause__Group__0__Impl rule__ReclassifyAllClause__Group__1

+            {

+            pushFollow(FOLLOW_rule__ReclassifyAllClause__Group__0__Impl_in_rule__ReclassifyAllClause__Group__030939);

+            rule__ReclassifyAllClause__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ReclassifyAllClause__Group__1_in_rule__ReclassifyAllClause__Group__030942);

+            rule__ReclassifyAllClause__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ReclassifyAllClause__Group__0"

+

+

+    // $ANTLR start "rule__ReclassifyAllClause__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15229:1: rule__ReclassifyAllClause__Group__0__Impl : ( () ) ;

+    public final void rule__ReclassifyAllClause__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15233:1: ( ( () ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15234:1: ( () )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15234:1: ( () )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15235:1: ()

+            {

+             before(grammarAccess.getReclassifyAllClauseAccess().getReclassifyAllClauseAction_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15236:1: ()

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15238:1: 

+            {

+            }

+

+             after(grammarAccess.getReclassifyAllClauseAccess().getReclassifyAllClauseAction_0()); 

+

+            }

+

+

+            }

+

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ReclassifyAllClause__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ReclassifyAllClause__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15248:1: rule__ReclassifyAllClause__Group__1 : rule__ReclassifyAllClause__Group__1__Impl rule__ReclassifyAllClause__Group__2 ;

+    public final void rule__ReclassifyAllClause__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15252:1: ( rule__ReclassifyAllClause__Group__1__Impl rule__ReclassifyAllClause__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15253:2: rule__ReclassifyAllClause__Group__1__Impl rule__ReclassifyAllClause__Group__2

+            {

+            pushFollow(FOLLOW_rule__ReclassifyAllClause__Group__1__Impl_in_rule__ReclassifyAllClause__Group__131000);

+            rule__ReclassifyAllClause__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ReclassifyAllClause__Group__2_in_rule__ReclassifyAllClause__Group__131003);

+            rule__ReclassifyAllClause__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ReclassifyAllClause__Group__1"

+

+

+    // $ANTLR start "rule__ReclassifyAllClause__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15260:1: rule__ReclassifyAllClause__Group__1__Impl : ( 'from' ) ;

+    public final void rule__ReclassifyAllClause__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15264:1: ( ( 'from' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15265:1: ( 'from' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15265:1: ( 'from' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15266:1: 'from'

+            {

+             before(grammarAccess.getReclassifyAllClauseAccess().getFromKeyword_1()); 

+            match(input,111,FOLLOW_111_in_rule__ReclassifyAllClause__Group__1__Impl31031); 

+             after(grammarAccess.getReclassifyAllClauseAccess().getFromKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ReclassifyAllClause__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ReclassifyAllClause__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15279:1: rule__ReclassifyAllClause__Group__2 : rule__ReclassifyAllClause__Group__2__Impl ;

+    public final void rule__ReclassifyAllClause__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15283:1: ( rule__ReclassifyAllClause__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15284:2: rule__ReclassifyAllClause__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__ReclassifyAllClause__Group__2__Impl_in_rule__ReclassifyAllClause__Group__231062);

+            rule__ReclassifyAllClause__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ReclassifyAllClause__Group__2"

+

+

+    // $ANTLR start "rule__ReclassifyAllClause__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15290:1: rule__ReclassifyAllClause__Group__2__Impl : ( '*' ) ;

+    public final void rule__ReclassifyAllClause__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15294:1: ( ( '*' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15295:1: ( '*' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15295:1: ( '*' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15296:1: '*'

+            {

+             before(grammarAccess.getReclassifyAllClauseAccess().getAsteriskKeyword_2()); 

+            match(input,27,FOLLOW_27_in_rule__ReclassifyAllClause__Group__2__Impl31090); 

+             after(grammarAccess.getReclassifyAllClauseAccess().getAsteriskKeyword_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ReclassifyAllClause__Group__2__Impl"

+

+

+    // $ANTLR start "rule__QualifiedNameList__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15315:1: rule__QualifiedNameList__Group__0 : rule__QualifiedNameList__Group__0__Impl rule__QualifiedNameList__Group__1 ;

+    public final void rule__QualifiedNameList__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15319:1: ( rule__QualifiedNameList__Group__0__Impl rule__QualifiedNameList__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15320:2: rule__QualifiedNameList__Group__0__Impl rule__QualifiedNameList__Group__1

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameList__Group__0__Impl_in_rule__QualifiedNameList__Group__031127);

+            rule__QualifiedNameList__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__QualifiedNameList__Group__1_in_rule__QualifiedNameList__Group__031130);

+            rule__QualifiedNameList__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameList__Group__0"

+

+

+    // $ANTLR start "rule__QualifiedNameList__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15327:1: rule__QualifiedNameList__Group__0__Impl : ( ( rule__QualifiedNameList__QualifiedNameAssignment_0 ) ) ;

+    public final void rule__QualifiedNameList__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15331:1: ( ( ( rule__QualifiedNameList__QualifiedNameAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15332:1: ( ( rule__QualifiedNameList__QualifiedNameAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15332:1: ( ( rule__QualifiedNameList__QualifiedNameAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15333:1: ( rule__QualifiedNameList__QualifiedNameAssignment_0 )

+            {

+             before(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15334:1: ( rule__QualifiedNameList__QualifiedNameAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15334:2: rule__QualifiedNameList__QualifiedNameAssignment_0

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameList__QualifiedNameAssignment_0_in_rule__QualifiedNameList__Group__0__Impl31157);

+            rule__QualifiedNameList__QualifiedNameAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameList__Group__0__Impl"

+

+

+    // $ANTLR start "rule__QualifiedNameList__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15344:1: rule__QualifiedNameList__Group__1 : rule__QualifiedNameList__Group__1__Impl ;

+    public final void rule__QualifiedNameList__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15348:1: ( rule__QualifiedNameList__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15349:2: rule__QualifiedNameList__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameList__Group__1__Impl_in_rule__QualifiedNameList__Group__131187);

+            rule__QualifiedNameList__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameList__Group__1"

+

+

+    // $ANTLR start "rule__QualifiedNameList__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15355:1: rule__QualifiedNameList__Group__1__Impl : ( ( rule__QualifiedNameList__Group_1__0 )* ) ;

+    public final void rule__QualifiedNameList__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15359:1: ( ( ( rule__QualifiedNameList__Group_1__0 )* ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15360:1: ( ( rule__QualifiedNameList__Group_1__0 )* )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15360:1: ( ( rule__QualifiedNameList__Group_1__0 )* )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15361:1: ( rule__QualifiedNameList__Group_1__0 )*

+            {

+             before(grammarAccess.getQualifiedNameListAccess().getGroup_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15362:1: ( rule__QualifiedNameList__Group_1__0 )*

+            loop101:

+            do {

+                int alt101=2;

+                int LA101_0 = input.LA(1);

+

+                if ( (LA101_0==66) ) {

+                    alt101=1;

+                }

+

+

+                switch (alt101) {

+            	case 1 :

+            	    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15362:2: rule__QualifiedNameList__Group_1__0

+            	    {

+            	    pushFollow(FOLLOW_rule__QualifiedNameList__Group_1__0_in_rule__QualifiedNameList__Group__1__Impl31214);

+            	    rule__QualifiedNameList__Group_1__0();

+

+            	    state._fsp--;

+

+

+            	    }

+            	    break;

+

+            	default :

+            	    break loop101;

+                }

+            } while (true);

+

+             after(grammarAccess.getQualifiedNameListAccess().getGroup_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameList__Group__1__Impl"

+

+

+    // $ANTLR start "rule__QualifiedNameList__Group_1__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15376:1: rule__QualifiedNameList__Group_1__0 : rule__QualifiedNameList__Group_1__0__Impl rule__QualifiedNameList__Group_1__1 ;

+    public final void rule__QualifiedNameList__Group_1__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15380:1: ( rule__QualifiedNameList__Group_1__0__Impl rule__QualifiedNameList__Group_1__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15381:2: rule__QualifiedNameList__Group_1__0__Impl rule__QualifiedNameList__Group_1__1

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameList__Group_1__0__Impl_in_rule__QualifiedNameList__Group_1__031249);

+            rule__QualifiedNameList__Group_1__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__QualifiedNameList__Group_1__1_in_rule__QualifiedNameList__Group_1__031252);

+            rule__QualifiedNameList__Group_1__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameList__Group_1__0"

+

+

+    // $ANTLR start "rule__QualifiedNameList__Group_1__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15388:1: rule__QualifiedNameList__Group_1__0__Impl : ( ',' ) ;

+    public final void rule__QualifiedNameList__Group_1__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15392:1: ( ( ',' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15393:1: ( ',' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15393:1: ( ',' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15394:1: ','

+            {

+             before(grammarAccess.getQualifiedNameListAccess().getCommaKeyword_1_0()); 

+            match(input,66,FOLLOW_66_in_rule__QualifiedNameList__Group_1__0__Impl31280); 

+             after(grammarAccess.getQualifiedNameListAccess().getCommaKeyword_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameList__Group_1__0__Impl"

+

+

+    // $ANTLR start "rule__QualifiedNameList__Group_1__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15407:1: rule__QualifiedNameList__Group_1__1 : rule__QualifiedNameList__Group_1__1__Impl ;

+    public final void rule__QualifiedNameList__Group_1__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15411:1: ( rule__QualifiedNameList__Group_1__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15412:2: rule__QualifiedNameList__Group_1__1__Impl

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameList__Group_1__1__Impl_in_rule__QualifiedNameList__Group_1__131311);

+            rule__QualifiedNameList__Group_1__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameList__Group_1__1"

+

+

+    // $ANTLR start "rule__QualifiedNameList__Group_1__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15418:1: rule__QualifiedNameList__Group_1__1__Impl : ( ( rule__QualifiedNameList__QualifiedNameAssignment_1_1 ) ) ;

+    public final void rule__QualifiedNameList__Group_1__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15422:1: ( ( ( rule__QualifiedNameList__QualifiedNameAssignment_1_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15423:1: ( ( rule__QualifiedNameList__QualifiedNameAssignment_1_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15423:1: ( ( rule__QualifiedNameList__QualifiedNameAssignment_1_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15424:1: ( rule__QualifiedNameList__QualifiedNameAssignment_1_1 )

+            {

+             before(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_1_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15425:1: ( rule__QualifiedNameList__QualifiedNameAssignment_1_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15425:2: rule__QualifiedNameList__QualifiedNameAssignment_1_1

+            {

+            pushFollow(FOLLOW_rule__QualifiedNameList__QualifiedNameAssignment_1_1_in_rule__QualifiedNameList__Group_1__1__Impl31338);

+            rule__QualifiedNameList__QualifiedNameAssignment_1_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getQualifiedNameListAccess().getQualifiedNameAssignment_1_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameList__Group_1__1__Impl"

+

+

+    // $ANTLR start "rule__InvocationOrAssignementOrDeclarationStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15439:1: rule__InvocationOrAssignementOrDeclarationStatement__Group__0 : rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl rule__InvocationOrAssignementOrDeclarationStatement__Group__1 ;

+    public final void rule__InvocationOrAssignementOrDeclarationStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15443:1: ( rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl rule__InvocationOrAssignementOrDeclarationStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15444:2: rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl rule__InvocationOrAssignementOrDeclarationStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__031372);

+            rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Group__1_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__031375);

+            rule__InvocationOrAssignementOrDeclarationStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InvocationOrAssignementOrDeclarationStatement__Group__0"

+

+

+    // $ANTLR start "rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15451:1: rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl : ( ( rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0 ) ) ;

+    public final void rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15455:1: ( ( ( rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15456:1: ( ( rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15456:1: ( ( rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15457:1: ( rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0 )

+            {

+             before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15458:1: ( rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15458:2: rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0

+            {

+            pushFollow(FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl31402);

+            rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__InvocationOrAssignementOrDeclarationStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15468:1: rule__InvocationOrAssignementOrDeclarationStatement__Group__1 : rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl rule__InvocationOrAssignementOrDeclarationStatement__Group__2 ;

+    public final void rule__InvocationOrAssignementOrDeclarationStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15472:1: ( rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl rule__InvocationOrAssignementOrDeclarationStatement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15473:2: rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl rule__InvocationOrAssignementOrDeclarationStatement__Group__2

+            {

+            pushFollow(FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__131432);

+            rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Group__2_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__131435);

+            rule__InvocationOrAssignementOrDeclarationStatement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InvocationOrAssignementOrDeclarationStatement__Group__1"

+

+

+    // $ANTLR start "rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15480:1: rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl : ( ( rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1 )? ) ;

+    public final void rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15484:1: ( ( ( rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15485:1: ( ( rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15485:1: ( ( rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15486:1: ( rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1 )?

+            {

+             before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAlternatives_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15487:1: ( rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1 )?

+            int alt102=2;

+            int LA102_0 = input.LA(1);

+

+            if ( (LA102_0==RULE_ID||(LA102_0>=49 && LA102_0<=60)||LA102_0==78) ) {

+                alt102=1;

+            }

+            switch (alt102) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15487:2: rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1

+                    {

+                    pushFollow(FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl31462);

+                    rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAlternatives_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__InvocationOrAssignementOrDeclarationStatement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15497:1: rule__InvocationOrAssignementOrDeclarationStatement__Group__2 : rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl ;

+    public final void rule__InvocationOrAssignementOrDeclarationStatement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15501:1: ( rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15502:2: rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__231493);

+            rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InvocationOrAssignementOrDeclarationStatement__Group__2"

+

+

+    // $ANTLR start "rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15508:1: rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl : ( ';' ) ;

+    public final void rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15512:1: ( ( ';' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15513:1: ( ';' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15513:1: ( ';' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15514:1: ';'

+            {

+             before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getSemicolonKeyword_2()); 

+            match(input,95,FOLLOW_95_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl31521); 

+             after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getSemicolonKeyword_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__SuperInvocationStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15533:1: rule__SuperInvocationStatement__Group__0 : rule__SuperInvocationStatement__Group__0__Impl rule__SuperInvocationStatement__Group__1 ;

+    public final void rule__SuperInvocationStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15537:1: ( rule__SuperInvocationStatement__Group__0__Impl rule__SuperInvocationStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15538:2: rule__SuperInvocationStatement__Group__0__Impl rule__SuperInvocationStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__SuperInvocationStatement__Group__0__Impl_in_rule__SuperInvocationStatement__Group__031558);

+            rule__SuperInvocationStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__SuperInvocationStatement__Group__1_in_rule__SuperInvocationStatement__Group__031561);

+            rule__SuperInvocationStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationStatement__Group__0"

+

+

+    // $ANTLR start "rule__SuperInvocationStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15545:1: rule__SuperInvocationStatement__Group__0__Impl : ( ( rule__SuperInvocationStatement___superAssignment_0 ) ) ;

+    public final void rule__SuperInvocationStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15549:1: ( ( ( rule__SuperInvocationStatement___superAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15550:1: ( ( rule__SuperInvocationStatement___superAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15550:1: ( ( rule__SuperInvocationStatement___superAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15551:1: ( rule__SuperInvocationStatement___superAssignment_0 )

+            {

+             before(grammarAccess.getSuperInvocationStatementAccess().get_superAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15552:1: ( rule__SuperInvocationStatement___superAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15552:2: rule__SuperInvocationStatement___superAssignment_0

+            {

+            pushFollow(FOLLOW_rule__SuperInvocationStatement___superAssignment_0_in_rule__SuperInvocationStatement__Group__0__Impl31588);

+            rule__SuperInvocationStatement___superAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getSuperInvocationStatementAccess().get_superAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__SuperInvocationStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15562:1: rule__SuperInvocationStatement__Group__1 : rule__SuperInvocationStatement__Group__1__Impl ;

+    public final void rule__SuperInvocationStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15566:1: ( rule__SuperInvocationStatement__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15567:2: rule__SuperInvocationStatement__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__SuperInvocationStatement__Group__1__Impl_in_rule__SuperInvocationStatement__Group__131618);

+            rule__SuperInvocationStatement__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationStatement__Group__1"

+

+

+    // $ANTLR start "rule__SuperInvocationStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15573:1: rule__SuperInvocationStatement__Group__1__Impl : ( ';' ) ;

+    public final void rule__SuperInvocationStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15577:1: ( ( ';' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15578:1: ( ';' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15578:1: ( ';' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15579:1: ';'

+            {

+             before(grammarAccess.getSuperInvocationStatementAccess().getSemicolonKeyword_1()); 

+            match(input,95,FOLLOW_95_in_rule__SuperInvocationStatement__Group__1__Impl31646); 

+             after(grammarAccess.getSuperInvocationStatementAccess().getSemicolonKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ThisInvocationStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15596:1: rule__ThisInvocationStatement__Group__0 : rule__ThisInvocationStatement__Group__0__Impl rule__ThisInvocationStatement__Group__1 ;

+    public final void rule__ThisInvocationStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15600:1: ( rule__ThisInvocationStatement__Group__0__Impl rule__ThisInvocationStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15601:2: rule__ThisInvocationStatement__Group__0__Impl rule__ThisInvocationStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__ThisInvocationStatement__Group__0__Impl_in_rule__ThisInvocationStatement__Group__031681);

+            rule__ThisInvocationStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ThisInvocationStatement__Group__1_in_rule__ThisInvocationStatement__Group__031684);

+            rule__ThisInvocationStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisInvocationStatement__Group__0"

+

+

+    // $ANTLR start "rule__ThisInvocationStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15608:1: rule__ThisInvocationStatement__Group__0__Impl : ( ( rule__ThisInvocationStatement___thisAssignment_0 ) ) ;

+    public final void rule__ThisInvocationStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15612:1: ( ( ( rule__ThisInvocationStatement___thisAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15613:1: ( ( rule__ThisInvocationStatement___thisAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15613:1: ( ( rule__ThisInvocationStatement___thisAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15614:1: ( rule__ThisInvocationStatement___thisAssignment_0 )

+            {

+             before(grammarAccess.getThisInvocationStatementAccess().get_thisAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15615:1: ( rule__ThisInvocationStatement___thisAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15615:2: rule__ThisInvocationStatement___thisAssignment_0

+            {

+            pushFollow(FOLLOW_rule__ThisInvocationStatement___thisAssignment_0_in_rule__ThisInvocationStatement__Group__0__Impl31711);

+            rule__ThisInvocationStatement___thisAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getThisInvocationStatementAccess().get_thisAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisInvocationStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__ThisInvocationStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15625:1: rule__ThisInvocationStatement__Group__1 : rule__ThisInvocationStatement__Group__1__Impl rule__ThisInvocationStatement__Group__2 ;

+    public final void rule__ThisInvocationStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15629:1: ( rule__ThisInvocationStatement__Group__1__Impl rule__ThisInvocationStatement__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15630:2: rule__ThisInvocationStatement__Group__1__Impl rule__ThisInvocationStatement__Group__2

+            {

+            pushFollow(FOLLOW_rule__ThisInvocationStatement__Group__1__Impl_in_rule__ThisInvocationStatement__Group__131741);

+            rule__ThisInvocationStatement__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__ThisInvocationStatement__Group__2_in_rule__ThisInvocationStatement__Group__131744);

+            rule__ThisInvocationStatement__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisInvocationStatement__Group__1"

+

+

+    // $ANTLR start "rule__ThisInvocationStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15637:1: rule__ThisInvocationStatement__Group__1__Impl : ( ( rule__ThisInvocationStatement__AssignmentCompletionAssignment_1 )? ) ;

+    public final void rule__ThisInvocationStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15641:1: ( ( ( rule__ThisInvocationStatement__AssignmentCompletionAssignment_1 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15642:1: ( ( rule__ThisInvocationStatement__AssignmentCompletionAssignment_1 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15642:1: ( ( rule__ThisInvocationStatement__AssignmentCompletionAssignment_1 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15643:1: ( rule__ThisInvocationStatement__AssignmentCompletionAssignment_1 )?

+            {

+             before(grammarAccess.getThisInvocationStatementAccess().getAssignmentCompletionAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15644:1: ( rule__ThisInvocationStatement__AssignmentCompletionAssignment_1 )?

+            int alt103=2;

+            int LA103_0 = input.LA(1);

+

+            if ( ((LA103_0>=49 && LA103_0<=60)) ) {

+                alt103=1;

+            }

+            switch (alt103) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15644:2: rule__ThisInvocationStatement__AssignmentCompletionAssignment_1

+                    {

+                    pushFollow(FOLLOW_rule__ThisInvocationStatement__AssignmentCompletionAssignment_1_in_rule__ThisInvocationStatement__Group__1__Impl31771);

+                    rule__ThisInvocationStatement__AssignmentCompletionAssignment_1();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getThisInvocationStatementAccess().getAssignmentCompletionAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisInvocationStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__ThisInvocationStatement__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15654:1: rule__ThisInvocationStatement__Group__2 : rule__ThisInvocationStatement__Group__2__Impl ;

+    public final void rule__ThisInvocationStatement__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15658:1: ( rule__ThisInvocationStatement__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15659:2: rule__ThisInvocationStatement__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__ThisInvocationStatement__Group__2__Impl_in_rule__ThisInvocationStatement__Group__231802);

+            rule__ThisInvocationStatement__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisInvocationStatement__Group__2"

+

+

+    // $ANTLR start "rule__ThisInvocationStatement__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15665:1: rule__ThisInvocationStatement__Group__2__Impl : ( ';' ) ;

+    public final void rule__ThisInvocationStatement__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15669:1: ( ( ';' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15670:1: ( ';' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15670:1: ( ';' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15671:1: ';'

+            {

+             before(grammarAccess.getThisInvocationStatementAccess().getSemicolonKeyword_2()); 

+            match(input,95,FOLLOW_95_in_rule__ThisInvocationStatement__Group__2__Impl31830); 

+             after(grammarAccess.getThisInvocationStatementAccess().getSemicolonKeyword_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisInvocationStatement__Group__2__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationInvocationStatement__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15690:1: rule__InstanceCreationInvocationStatement__Group__0 : rule__InstanceCreationInvocationStatement__Group__0__Impl rule__InstanceCreationInvocationStatement__Group__1 ;

+    public final void rule__InstanceCreationInvocationStatement__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15694:1: ( rule__InstanceCreationInvocationStatement__Group__0__Impl rule__InstanceCreationInvocationStatement__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15695:2: rule__InstanceCreationInvocationStatement__Group__0__Impl rule__InstanceCreationInvocationStatement__Group__1

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationInvocationStatement__Group__0__Impl_in_rule__InstanceCreationInvocationStatement__Group__031867);

+            rule__InstanceCreationInvocationStatement__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__InstanceCreationInvocationStatement__Group__1_in_rule__InstanceCreationInvocationStatement__Group__031870);

+            rule__InstanceCreationInvocationStatement__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationInvocationStatement__Group__0"

+

+

+    // $ANTLR start "rule__InstanceCreationInvocationStatement__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15702:1: rule__InstanceCreationInvocationStatement__Group__0__Impl : ( ( rule__InstanceCreationInvocationStatement___newAssignment_0 ) ) ;

+    public final void rule__InstanceCreationInvocationStatement__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15706:1: ( ( ( rule__InstanceCreationInvocationStatement___newAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15707:1: ( ( rule__InstanceCreationInvocationStatement___newAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15707:1: ( ( rule__InstanceCreationInvocationStatement___newAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15708:1: ( rule__InstanceCreationInvocationStatement___newAssignment_0 )

+            {

+             before(grammarAccess.getInstanceCreationInvocationStatementAccess().get_newAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15709:1: ( rule__InstanceCreationInvocationStatement___newAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15709:2: rule__InstanceCreationInvocationStatement___newAssignment_0

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationInvocationStatement___newAssignment_0_in_rule__InstanceCreationInvocationStatement__Group__0__Impl31897);

+            rule__InstanceCreationInvocationStatement___newAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getInstanceCreationInvocationStatementAccess().get_newAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationInvocationStatement__Group__0__Impl"

+

+

+    // $ANTLR start "rule__InstanceCreationInvocationStatement__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15719:1: rule__InstanceCreationInvocationStatement__Group__1 : rule__InstanceCreationInvocationStatement__Group__1__Impl ;

+    public final void rule__InstanceCreationInvocationStatement__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15723:1: ( rule__InstanceCreationInvocationStatement__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15724:2: rule__InstanceCreationInvocationStatement__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__InstanceCreationInvocationStatement__Group__1__Impl_in_rule__InstanceCreationInvocationStatement__Group__131927);

+            rule__InstanceCreationInvocationStatement__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationInvocationStatement__Group__1"

+

+

+    // $ANTLR start "rule__InstanceCreationInvocationStatement__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15730:1: rule__InstanceCreationInvocationStatement__Group__1__Impl : ( ';' ) ;

+    public final void rule__InstanceCreationInvocationStatement__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15734:1: ( ( ';' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15735:1: ( ';' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15735:1: ( ';' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15736:1: ';'

+            {

+             before(grammarAccess.getInstanceCreationInvocationStatementAccess().getSemicolonKeyword_1()); 

+            match(input,95,FOLLOW_95_in_rule__InstanceCreationInvocationStatement__Group__1__Impl31955); 

+             after(grammarAccess.getInstanceCreationInvocationStatementAccess().getSemicolonKeyword_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationInvocationStatement__Group__1__Impl"

+

+

+    // $ANTLR start "rule__VariableDeclarationCompletion__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15753:1: rule__VariableDeclarationCompletion__Group__0 : rule__VariableDeclarationCompletion__Group__0__Impl rule__VariableDeclarationCompletion__Group__1 ;

+    public final void rule__VariableDeclarationCompletion__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15757:1: ( rule__VariableDeclarationCompletion__Group__0__Impl rule__VariableDeclarationCompletion__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15758:2: rule__VariableDeclarationCompletion__Group__0__Impl rule__VariableDeclarationCompletion__Group__1

+            {

+            pushFollow(FOLLOW_rule__VariableDeclarationCompletion__Group__0__Impl_in_rule__VariableDeclarationCompletion__Group__031990);

+            rule__VariableDeclarationCompletion__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__VariableDeclarationCompletion__Group__1_in_rule__VariableDeclarationCompletion__Group__031993);

+            rule__VariableDeclarationCompletion__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__VariableDeclarationCompletion__Group__0"

+

+

+    // $ANTLR start "rule__VariableDeclarationCompletion__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15765:1: rule__VariableDeclarationCompletion__Group__0__Impl : ( ( rule__VariableDeclarationCompletion__Group_0__0 )? ) ;

+    public final void rule__VariableDeclarationCompletion__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15769:1: ( ( ( rule__VariableDeclarationCompletion__Group_0__0 )? ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15770:1: ( ( rule__VariableDeclarationCompletion__Group_0__0 )? )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15770:1: ( ( rule__VariableDeclarationCompletion__Group_0__0 )? )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15771:1: ( rule__VariableDeclarationCompletion__Group_0__0 )?

+            {

+             before(grammarAccess.getVariableDeclarationCompletionAccess().getGroup_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15772:1: ( rule__VariableDeclarationCompletion__Group_0__0 )?

+            int alt104=2;

+            int LA104_0 = input.LA(1);

+

+            if ( (LA104_0==78) ) {

+                alt104=1;

+            }

+            switch (alt104) {

+                case 1 :

+                    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15772:2: rule__VariableDeclarationCompletion__Group_0__0

+                    {

+                    pushFollow(FOLLOW_rule__VariableDeclarationCompletion__Group_0__0_in_rule__VariableDeclarationCompletion__Group__0__Impl32020);

+                    rule__VariableDeclarationCompletion__Group_0__0();

+

+                    state._fsp--;

+

+

+                    }

+                    break;

+

+            }

+

+             after(grammarAccess.getVariableDeclarationCompletionAccess().getGroup_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__VariableDeclarationCompletion__Group__0__Impl"

+

+

+    // $ANTLR start "rule__VariableDeclarationCompletion__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15782:1: rule__VariableDeclarationCompletion__Group__1 : rule__VariableDeclarationCompletion__Group__1__Impl rule__VariableDeclarationCompletion__Group__2 ;

+    public final void rule__VariableDeclarationCompletion__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15786:1: ( rule__VariableDeclarationCompletion__Group__1__Impl rule__VariableDeclarationCompletion__Group__2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15787:2: rule__VariableDeclarationCompletion__Group__1__Impl rule__VariableDeclarationCompletion__Group__2

+            {

+            pushFollow(FOLLOW_rule__VariableDeclarationCompletion__Group__1__Impl_in_rule__VariableDeclarationCompletion__Group__132051);

+            rule__VariableDeclarationCompletion__Group__1__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__VariableDeclarationCompletion__Group__2_in_rule__VariableDeclarationCompletion__Group__132054);

+            rule__VariableDeclarationCompletion__Group__2();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__VariableDeclarationCompletion__Group__1"

+

+

+    // $ANTLR start "rule__VariableDeclarationCompletion__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15794:1: rule__VariableDeclarationCompletion__Group__1__Impl : ( ( rule__VariableDeclarationCompletion__VariableNameAssignment_1 ) ) ;

+    public final void rule__VariableDeclarationCompletion__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15798:1: ( ( ( rule__VariableDeclarationCompletion__VariableNameAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15799:1: ( ( rule__VariableDeclarationCompletion__VariableNameAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15799:1: ( ( rule__VariableDeclarationCompletion__VariableNameAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15800:1: ( rule__VariableDeclarationCompletion__VariableNameAssignment_1 )

+            {

+             before(grammarAccess.getVariableDeclarationCompletionAccess().getVariableNameAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15801:1: ( rule__VariableDeclarationCompletion__VariableNameAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15801:2: rule__VariableDeclarationCompletion__VariableNameAssignment_1

+            {

+            pushFollow(FOLLOW_rule__VariableDeclarationCompletion__VariableNameAssignment_1_in_rule__VariableDeclarationCompletion__Group__1__Impl32081);

+            rule__VariableDeclarationCompletion__VariableNameAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getVariableDeclarationCompletionAccess().getVariableNameAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__VariableDeclarationCompletion__Group__1__Impl"

+

+

+    // $ANTLR start "rule__VariableDeclarationCompletion__Group__2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15811:1: rule__VariableDeclarationCompletion__Group__2 : rule__VariableDeclarationCompletion__Group__2__Impl ;

+    public final void rule__VariableDeclarationCompletion__Group__2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15815:1: ( rule__VariableDeclarationCompletion__Group__2__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15816:2: rule__VariableDeclarationCompletion__Group__2__Impl

+            {

+            pushFollow(FOLLOW_rule__VariableDeclarationCompletion__Group__2__Impl_in_rule__VariableDeclarationCompletion__Group__232111);

+            rule__VariableDeclarationCompletion__Group__2__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__VariableDeclarationCompletion__Group__2"

+

+

+    // $ANTLR start "rule__VariableDeclarationCompletion__Group__2__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15822:1: rule__VariableDeclarationCompletion__Group__2__Impl : ( ( rule__VariableDeclarationCompletion__InitValueAssignment_2 ) ) ;

+    public final void rule__VariableDeclarationCompletion__Group__2__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15826:1: ( ( ( rule__VariableDeclarationCompletion__InitValueAssignment_2 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15827:1: ( ( rule__VariableDeclarationCompletion__InitValueAssignment_2 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15827:1: ( ( rule__VariableDeclarationCompletion__InitValueAssignment_2 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15828:1: ( rule__VariableDeclarationCompletion__InitValueAssignment_2 )

+            {

+             before(grammarAccess.getVariableDeclarationCompletionAccess().getInitValueAssignment_2()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15829:1: ( rule__VariableDeclarationCompletion__InitValueAssignment_2 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15829:2: rule__VariableDeclarationCompletion__InitValueAssignment_2

+            {

+            pushFollow(FOLLOW_rule__VariableDeclarationCompletion__InitValueAssignment_2_in_rule__VariableDeclarationCompletion__Group__2__Impl32138);

+            rule__VariableDeclarationCompletion__InitValueAssignment_2();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getVariableDeclarationCompletionAccess().getInitValueAssignment_2()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__VariableDeclarationCompletion__Group__2__Impl"

+

+

+    // $ANTLR start "rule__VariableDeclarationCompletion__Group_0__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15845:1: rule__VariableDeclarationCompletion__Group_0__0 : rule__VariableDeclarationCompletion__Group_0__0__Impl rule__VariableDeclarationCompletion__Group_0__1 ;

+    public final void rule__VariableDeclarationCompletion__Group_0__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15849:1: ( rule__VariableDeclarationCompletion__Group_0__0__Impl rule__VariableDeclarationCompletion__Group_0__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15850:2: rule__VariableDeclarationCompletion__Group_0__0__Impl rule__VariableDeclarationCompletion__Group_0__1

+            {

+            pushFollow(FOLLOW_rule__VariableDeclarationCompletion__Group_0__0__Impl_in_rule__VariableDeclarationCompletion__Group_0__032174);

+            rule__VariableDeclarationCompletion__Group_0__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__VariableDeclarationCompletion__Group_0__1_in_rule__VariableDeclarationCompletion__Group_0__032177);

+            rule__VariableDeclarationCompletion__Group_0__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__VariableDeclarationCompletion__Group_0__0"

+

+

+    // $ANTLR start "rule__VariableDeclarationCompletion__Group_0__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15857:1: rule__VariableDeclarationCompletion__Group_0__0__Impl : ( ( rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0 ) ) ;

+    public final void rule__VariableDeclarationCompletion__Group_0__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15861:1: ( ( ( rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15862:1: ( ( rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15862:1: ( ( rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15863:1: ( rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0 )

+            {

+             before(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorAssignment_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15864:1: ( rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15864:2: rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0

+            {

+            pushFollow(FOLLOW_rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0_in_rule__VariableDeclarationCompletion__Group_0__0__Impl32204);

+            rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorAssignment_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__VariableDeclarationCompletion__Group_0__0__Impl"

+

+

+    // $ANTLR start "rule__VariableDeclarationCompletion__Group_0__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15874:1: rule__VariableDeclarationCompletion__Group_0__1 : rule__VariableDeclarationCompletion__Group_0__1__Impl ;

+    public final void rule__VariableDeclarationCompletion__Group_0__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15878:1: ( rule__VariableDeclarationCompletion__Group_0__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15879:2: rule__VariableDeclarationCompletion__Group_0__1__Impl

+            {

+            pushFollow(FOLLOW_rule__VariableDeclarationCompletion__Group_0__1__Impl_in_rule__VariableDeclarationCompletion__Group_0__132234);

+            rule__VariableDeclarationCompletion__Group_0__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__VariableDeclarationCompletion__Group_0__1"

+

+

+    // $ANTLR start "rule__VariableDeclarationCompletion__Group_0__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15885:1: rule__VariableDeclarationCompletion__Group_0__1__Impl : ( ']' ) ;

+    public final void rule__VariableDeclarationCompletion__Group_0__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15889:1: ( ( ']' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15890:1: ( ']' )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15890:1: ( ']' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15891:1: ']'

+            {

+             before(grammarAccess.getVariableDeclarationCompletionAccess().getRightSquareBracketKeyword_0_1()); 

+            match(input,79,FOLLOW_79_in_rule__VariableDeclarationCompletion__Group_0__1__Impl32262); 

+             after(grammarAccess.getVariableDeclarationCompletionAccess().getRightSquareBracketKeyword_0_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__VariableDeclarationCompletion__Group_0__1__Impl"

+

+

+    // $ANTLR start "rule__AssignmentCompletion__Group__0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15908:1: rule__AssignmentCompletion__Group__0 : rule__AssignmentCompletion__Group__0__Impl rule__AssignmentCompletion__Group__1 ;

+    public final void rule__AssignmentCompletion__Group__0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15912:1: ( rule__AssignmentCompletion__Group__0__Impl rule__AssignmentCompletion__Group__1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15913:2: rule__AssignmentCompletion__Group__0__Impl rule__AssignmentCompletion__Group__1

+            {

+            pushFollow(FOLLOW_rule__AssignmentCompletion__Group__0__Impl_in_rule__AssignmentCompletion__Group__032297);

+            rule__AssignmentCompletion__Group__0__Impl();

+

+            state._fsp--;

+

+            pushFollow(FOLLOW_rule__AssignmentCompletion__Group__1_in_rule__AssignmentCompletion__Group__032300);

+            rule__AssignmentCompletion__Group__1();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AssignmentCompletion__Group__0"

+

+

+    // $ANTLR start "rule__AssignmentCompletion__Group__0__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15920:1: rule__AssignmentCompletion__Group__0__Impl : ( ( rule__AssignmentCompletion__OpAssignment_0 ) ) ;

+    public final void rule__AssignmentCompletion__Group__0__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15924:1: ( ( ( rule__AssignmentCompletion__OpAssignment_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15925:1: ( ( rule__AssignmentCompletion__OpAssignment_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15925:1: ( ( rule__AssignmentCompletion__OpAssignment_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15926:1: ( rule__AssignmentCompletion__OpAssignment_0 )

+            {

+             before(grammarAccess.getAssignmentCompletionAccess().getOpAssignment_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15927:1: ( rule__AssignmentCompletion__OpAssignment_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15927:2: rule__AssignmentCompletion__OpAssignment_0

+            {

+            pushFollow(FOLLOW_rule__AssignmentCompletion__OpAssignment_0_in_rule__AssignmentCompletion__Group__0__Impl32327);

+            rule__AssignmentCompletion__OpAssignment_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAssignmentCompletionAccess().getOpAssignment_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AssignmentCompletion__Group__0__Impl"

+

+

+    // $ANTLR start "rule__AssignmentCompletion__Group__1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15937:1: rule__AssignmentCompletion__Group__1 : rule__AssignmentCompletion__Group__1__Impl ;

+    public final void rule__AssignmentCompletion__Group__1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15941:1: ( rule__AssignmentCompletion__Group__1__Impl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15942:2: rule__AssignmentCompletion__Group__1__Impl

+            {

+            pushFollow(FOLLOW_rule__AssignmentCompletion__Group__1__Impl_in_rule__AssignmentCompletion__Group__132357);

+            rule__AssignmentCompletion__Group__1__Impl();

+

+            state._fsp--;

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AssignmentCompletion__Group__1"

+

+

+    // $ANTLR start "rule__AssignmentCompletion__Group__1__Impl"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15948:1: rule__AssignmentCompletion__Group__1__Impl : ( ( rule__AssignmentCompletion__RightHandSideAssignment_1 ) ) ;

+    public final void rule__AssignmentCompletion__Group__1__Impl() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15952:1: ( ( ( rule__AssignmentCompletion__RightHandSideAssignment_1 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15953:1: ( ( rule__AssignmentCompletion__RightHandSideAssignment_1 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15953:1: ( ( rule__AssignmentCompletion__RightHandSideAssignment_1 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15954:1: ( rule__AssignmentCompletion__RightHandSideAssignment_1 )

+            {

+             before(grammarAccess.getAssignmentCompletionAccess().getRightHandSideAssignment_1()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15955:1: ( rule__AssignmentCompletion__RightHandSideAssignment_1 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15955:2: rule__AssignmentCompletion__RightHandSideAssignment_1

+            {

+            pushFollow(FOLLOW_rule__AssignmentCompletion__RightHandSideAssignment_1_in_rule__AssignmentCompletion__Group__1__Impl32384);

+            rule__AssignmentCompletion__RightHandSideAssignment_1();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAssignmentCompletionAccess().getRightHandSideAssignment_1()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AssignmentCompletion__Group__1__Impl"

+

+

+    // $ANTLR start "rule__Test__ExpressionAssignment_0_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15970:1: rule__Test__ExpressionAssignment_0_1 : ( ruleExpression ) ;

+    public final void rule__Test__ExpressionAssignment_0_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15974:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15975:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15975:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15976:1: ruleExpression

+            {

+             before(grammarAccess.getTestAccess().getExpressionExpressionParserRuleCall_0_1_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__Test__ExpressionAssignment_0_132423);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getTestAccess().getExpressionExpressionParserRuleCall_0_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__ExpressionAssignment_0_1"

+

+

+    // $ANTLR start "rule__Test__AssignExpressionAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15985:1: rule__Test__AssignExpressionAssignment_1_1 : ( ruleAssignmentCompletion ) ;

+    public final void rule__Test__AssignExpressionAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15989:1: ( ( ruleAssignmentCompletion ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15990:1: ( ruleAssignmentCompletion )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15990:1: ( ruleAssignmentCompletion )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:15991:1: ruleAssignmentCompletion

+            {

+             before(grammarAccess.getTestAccess().getAssignExpressionAssignmentCompletionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleAssignmentCompletion_in_rule__Test__AssignExpressionAssignment_1_132454);

+            ruleAssignmentCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getTestAccess().getAssignExpressionAssignmentCompletionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__AssignExpressionAssignment_1_1"

+

+

+    // $ANTLR start "rule__Test__StatementsAssignment_2_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16000:1: rule__Test__StatementsAssignment_2_1 : ( ruleStatement ) ;

+    public final void rule__Test__StatementsAssignment_2_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16004:1: ( ( ruleStatement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16005:1: ( ruleStatement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16005:1: ( ruleStatement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16006:1: ruleStatement

+            {

+             before(grammarAccess.getTestAccess().getStatementsStatementParserRuleCall_2_1_0()); 

+            pushFollow(FOLLOW_ruleStatement_in_rule__Test__StatementsAssignment_2_132485);

+            ruleStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getTestAccess().getStatementsStatementParserRuleCall_2_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__StatementsAssignment_2_1"

+

+

+    // $ANTLR start "rule__Test__BlockAssignment_3_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16015:1: rule__Test__BlockAssignment_3_1 : ( ruleBlock ) ;

+    public final void rule__Test__BlockAssignment_3_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16019:1: ( ( ruleBlock ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16020:1: ( ruleBlock )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16020:1: ( ruleBlock )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16021:1: ruleBlock

+            {

+             before(grammarAccess.getTestAccess().getBlockBlockParserRuleCall_3_1_0()); 

+            pushFollow(FOLLOW_ruleBlock_in_rule__Test__BlockAssignment_3_132516);

+            ruleBlock();

+

+            state._fsp--;

+

+             after(grammarAccess.getTestAccess().getBlockBlockParserRuleCall_3_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Test__BlockAssignment_3_1"

+

+

+    // $ANTLR start "rule__BOOLEAN_LITERAL__ValueAssignment"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16030:1: rule__BOOLEAN_LITERAL__ValueAssignment : ( ruleBooleanValue ) ;

+    public final void rule__BOOLEAN_LITERAL__ValueAssignment() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16034:1: ( ( ruleBooleanValue ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16035:1: ( ruleBooleanValue )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16035:1: ( ruleBooleanValue )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16036:1: ruleBooleanValue

+            {

+             before(grammarAccess.getBOOLEAN_LITERALAccess().getValueBooleanValueEnumRuleCall_0()); 

+            pushFollow(FOLLOW_ruleBooleanValue_in_rule__BOOLEAN_LITERAL__ValueAssignment32547);

+            ruleBooleanValue();

+

+            state._fsp--;

+

+             after(grammarAccess.getBOOLEAN_LITERALAccess().getValueBooleanValueEnumRuleCall_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__BOOLEAN_LITERAL__ValueAssignment"

+

+

+    // $ANTLR start "rule__INTEGER_LITERAL__ValueAssignment"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16045:1: rule__INTEGER_LITERAL__ValueAssignment : ( RULE_INTEGERVALUE ) ;

+    public final void rule__INTEGER_LITERAL__ValueAssignment() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16049:1: ( ( RULE_INTEGERVALUE ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16050:1: ( RULE_INTEGERVALUE )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16050:1: ( RULE_INTEGERVALUE )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16051:1: RULE_INTEGERVALUE

+            {

+             before(grammarAccess.getINTEGER_LITERALAccess().getValueIntegerValueTerminalRuleCall_0()); 

+            match(input,RULE_INTEGERVALUE,FOLLOW_RULE_INTEGERVALUE_in_rule__INTEGER_LITERAL__ValueAssignment32578); 

+             after(grammarAccess.getINTEGER_LITERALAccess().getValueIntegerValueTerminalRuleCall_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__INTEGER_LITERAL__ValueAssignment"

+

+

+    // $ANTLR start "rule__UNLIMITED_LITERAL__ValueAssignment"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16060:1: rule__UNLIMITED_LITERAL__ValueAssignment : ( ( '*' ) ) ;

+    public final void rule__UNLIMITED_LITERAL__ValueAssignment() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16064:1: ( ( ( '*' ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16065:1: ( ( '*' ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16065:1: ( ( '*' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16066:1: ( '*' )

+            {

+             before(grammarAccess.getUNLIMITED_LITERALAccess().getValueAsteriskKeyword_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16067:1: ( '*' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16068:1: '*'

+            {

+             before(grammarAccess.getUNLIMITED_LITERALAccess().getValueAsteriskKeyword_0()); 

+            match(input,27,FOLLOW_27_in_rule__UNLIMITED_LITERAL__ValueAssignment32614); 

+             after(grammarAccess.getUNLIMITED_LITERALAccess().getValueAsteriskKeyword_0()); 

+

+            }

+

+             after(grammarAccess.getUNLIMITED_LITERALAccess().getValueAsteriskKeyword_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UNLIMITED_LITERAL__ValueAssignment"

+

+

+    // $ANTLR start "rule__STRING_LITERAL__ValueAssignment"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16083:1: rule__STRING_LITERAL__ValueAssignment : ( RULE_STRING ) ;

+    public final void rule__STRING_LITERAL__ValueAssignment() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16087:1: ( ( RULE_STRING ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16088:1: ( RULE_STRING )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16088:1: ( RULE_STRING )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16089:1: RULE_STRING

+            {

+             before(grammarAccess.getSTRING_LITERALAccess().getValueSTRINGTerminalRuleCall_0()); 

+            match(input,RULE_STRING,FOLLOW_RULE_STRING_in_rule__STRING_LITERAL__ValueAssignment32653); 

+             after(grammarAccess.getSTRING_LITERALAccess().getValueSTRINGTerminalRuleCall_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__STRING_LITERAL__ValueAssignment"

+

+

+    // $ANTLR start "rule__NameExpression__PrefixOpAssignment_0_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16098:1: rule__NameExpression__PrefixOpAssignment_0_0_0 : ( ( rule__NameExpression__PrefixOpAlternatives_0_0_0_0 ) ) ;

+    public final void rule__NameExpression__PrefixOpAssignment_0_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16102:1: ( ( ( rule__NameExpression__PrefixOpAlternatives_0_0_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16103:1: ( ( rule__NameExpression__PrefixOpAlternatives_0_0_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16103:1: ( ( rule__NameExpression__PrefixOpAlternatives_0_0_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16104:1: ( rule__NameExpression__PrefixOpAlternatives_0_0_0_0 )

+            {

+             before(grammarAccess.getNameExpressionAccess().getPrefixOpAlternatives_0_0_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16105:1: ( rule__NameExpression__PrefixOpAlternatives_0_0_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16105:2: rule__NameExpression__PrefixOpAlternatives_0_0_0_0

+            {

+            pushFollow(FOLLOW_rule__NameExpression__PrefixOpAlternatives_0_0_0_0_in_rule__NameExpression__PrefixOpAssignment_0_0_032684);

+            rule__NameExpression__PrefixOpAlternatives_0_0_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNameExpressionAccess().getPrefixOpAlternatives_0_0_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__PrefixOpAssignment_0_0_0"

+

+

+    // $ANTLR start "rule__NameExpression__PathAssignment_0_0_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16114:1: rule__NameExpression__PathAssignment_0_0_1 : ( ruleQualifiedNamePath ) ;

+    public final void rule__NameExpression__PathAssignment_0_0_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16118:1: ( ( ruleQualifiedNamePath ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16119:1: ( ruleQualifiedNamePath )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16119:1: ( ruleQualifiedNamePath )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16120:1: ruleQualifiedNamePath

+            {

+             before(grammarAccess.getNameExpressionAccess().getPathQualifiedNamePathParserRuleCall_0_0_1_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNamePath_in_rule__NameExpression__PathAssignment_0_0_132717);

+            ruleQualifiedNamePath();

+

+            state._fsp--;

+

+             after(grammarAccess.getNameExpressionAccess().getPathQualifiedNamePathParserRuleCall_0_0_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__PathAssignment_0_0_1"

+

+

+    // $ANTLR start "rule__NameExpression__IdAssignment_0_0_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16129:1: rule__NameExpression__IdAssignment_0_0_2 : ( RULE_ID ) ;

+    public final void rule__NameExpression__IdAssignment_0_0_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16133:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16134:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16134:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16135:1: RULE_ID

+            {

+             before(grammarAccess.getNameExpressionAccess().getIdIDTerminalRuleCall_0_0_2_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__NameExpression__IdAssignment_0_0_232748); 

+             after(grammarAccess.getNameExpressionAccess().getIdIDTerminalRuleCall_0_0_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__IdAssignment_0_0_2"

+

+

+    // $ANTLR start "rule__NameExpression__PathAssignment_0_1_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16144:1: rule__NameExpression__PathAssignment_0_1_0 : ( ruleQualifiedNamePath ) ;

+    public final void rule__NameExpression__PathAssignment_0_1_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16148:1: ( ( ruleQualifiedNamePath ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16149:1: ( ruleQualifiedNamePath )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16149:1: ( ruleQualifiedNamePath )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16150:1: ruleQualifiedNamePath

+            {

+             before(grammarAccess.getNameExpressionAccess().getPathQualifiedNamePathParserRuleCall_0_1_0_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNamePath_in_rule__NameExpression__PathAssignment_0_1_032779);

+            ruleQualifiedNamePath();

+

+            state._fsp--;

+

+             after(grammarAccess.getNameExpressionAccess().getPathQualifiedNamePathParserRuleCall_0_1_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__PathAssignment_0_1_0"

+

+

+    // $ANTLR start "rule__NameExpression__IdAssignment_0_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16159:1: rule__NameExpression__IdAssignment_0_1_1 : ( RULE_ID ) ;

+    public final void rule__NameExpression__IdAssignment_0_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16163:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16164:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16164:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16165:1: RULE_ID

+            {

+             before(grammarAccess.getNameExpressionAccess().getIdIDTerminalRuleCall_0_1_1_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__NameExpression__IdAssignment_0_1_132810); 

+             after(grammarAccess.getNameExpressionAccess().getIdIDTerminalRuleCall_0_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__IdAssignment_0_1_1"

+

+

+    // $ANTLR start "rule__NameExpression__InvocationCompletionAssignment_0_1_2_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16174:1: rule__NameExpression__InvocationCompletionAssignment_0_1_2_0 : ( ruleTuple ) ;

+    public final void rule__NameExpression__InvocationCompletionAssignment_0_1_2_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16178:1: ( ( ruleTuple ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16179:1: ( ruleTuple )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16179:1: ( ruleTuple )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16180:1: ruleTuple

+            {

+             before(grammarAccess.getNameExpressionAccess().getInvocationCompletionTupleParserRuleCall_0_1_2_0_0()); 

+            pushFollow(FOLLOW_ruleTuple_in_rule__NameExpression__InvocationCompletionAssignment_0_1_2_032841);

+            ruleTuple();

+

+            state._fsp--;

+

+             after(grammarAccess.getNameExpressionAccess().getInvocationCompletionTupleParserRuleCall_0_1_2_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__InvocationCompletionAssignment_0_1_2_0"

+

+

+    // $ANTLR start "rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16189:1: rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1 : ( ruleSequenceConstructionOrAccessCompletion ) ;

+    public final void rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16193:1: ( ( ruleSequenceConstructionOrAccessCompletion ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16194:1: ( ruleSequenceConstructionOrAccessCompletion )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16194:1: ( ruleSequenceConstructionOrAccessCompletion )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16195:1: ruleSequenceConstructionOrAccessCompletion

+            {

+             before(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionSequenceConstructionOrAccessCompletionParserRuleCall_0_1_2_1_0()); 

+            pushFollow(FOLLOW_ruleSequenceConstructionOrAccessCompletion_in_rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_132872);

+            ruleSequenceConstructionOrAccessCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getNameExpressionAccess().getSequenceConstructionCompletionSequenceConstructionOrAccessCompletionParserRuleCall_0_1_2_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1"

+

+

+    // $ANTLR start "rule__NameExpression__PostfixOpAssignment_0_1_2_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16204:1: rule__NameExpression__PostfixOpAssignment_0_1_2_2 : ( ( rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0 ) ) ;

+    public final void rule__NameExpression__PostfixOpAssignment_0_1_2_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16208:1: ( ( ( rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16209:1: ( ( rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16209:1: ( ( rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16210:1: ( rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0 )

+            {

+             before(grammarAccess.getNameExpressionAccess().getPostfixOpAlternatives_0_1_2_2_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16211:1: ( rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16211:2: rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0

+            {

+            pushFollow(FOLLOW_rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0_in_rule__NameExpression__PostfixOpAssignment_0_1_2_232903);

+            rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getNameExpressionAccess().getPostfixOpAlternatives_0_1_2_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__PostfixOpAssignment_0_1_2_2"

+

+

+    // $ANTLR start "rule__NameExpression__SuffixAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16220:1: rule__NameExpression__SuffixAssignment_1 : ( ruleSuffixExpression ) ;

+    public final void rule__NameExpression__SuffixAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16224:1: ( ( ruleSuffixExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16225:1: ( ruleSuffixExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16225:1: ( ruleSuffixExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16226:1: ruleSuffixExpression

+            {

+             before(grammarAccess.getNameExpressionAccess().getSuffixSuffixExpressionParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleSuffixExpression_in_rule__NameExpression__SuffixAssignment_132936);

+            ruleSuffixExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getNameExpressionAccess().getSuffixSuffixExpressionParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NameExpression__SuffixAssignment_1"

+

+

+    // $ANTLR start "rule__QualifiedNamePath__NamespaceAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16235:1: rule__QualifiedNamePath__NamespaceAssignment_0 : ( ruleUnqualifiedName ) ;

+    public final void rule__QualifiedNamePath__NamespaceAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16239:1: ( ( ruleUnqualifiedName ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16240:1: ( ruleUnqualifiedName )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16240:1: ( ruleUnqualifiedName )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16241:1: ruleUnqualifiedName

+            {

+             before(grammarAccess.getQualifiedNamePathAccess().getNamespaceUnqualifiedNameParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleUnqualifiedName_in_rule__QualifiedNamePath__NamespaceAssignment_032967);

+            ruleUnqualifiedName();

+

+            state._fsp--;

+

+             after(grammarAccess.getQualifiedNamePathAccess().getNamespaceUnqualifiedNameParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNamePath__NamespaceAssignment_0"

+

+

+    // $ANTLR start "rule__UnqualifiedName__NameAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16250:1: rule__UnqualifiedName__NameAssignment_0 : ( RULE_ID ) ;

+    public final void rule__UnqualifiedName__NameAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16254:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16255:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16255:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16256:1: RULE_ID

+            {

+             before(grammarAccess.getUnqualifiedNameAccess().getNameIDTerminalRuleCall_0_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__UnqualifiedName__NameAssignment_032998); 

+             after(grammarAccess.getUnqualifiedNameAccess().getNameIDTerminalRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UnqualifiedName__NameAssignment_0"

+

+

+    // $ANTLR start "rule__UnqualifiedName__TemplateBindingAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16265:1: rule__UnqualifiedName__TemplateBindingAssignment_1 : ( ruleTemplateBinding ) ;

+    public final void rule__UnqualifiedName__TemplateBindingAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16269:1: ( ( ruleTemplateBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16270:1: ( ruleTemplateBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16270:1: ( ruleTemplateBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16271:1: ruleTemplateBinding

+            {

+             before(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingTemplateBindingParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleTemplateBinding_in_rule__UnqualifiedName__TemplateBindingAssignment_133029);

+            ruleTemplateBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getUnqualifiedNameAccess().getTemplateBindingTemplateBindingParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UnqualifiedName__TemplateBindingAssignment_1"

+

+

+    // $ANTLR start "rule__TemplateBinding__BindingsAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16280:1: rule__TemplateBinding__BindingsAssignment_1 : ( ruleNamedTemplateBinding ) ;

+    public final void rule__TemplateBinding__BindingsAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16284:1: ( ( ruleNamedTemplateBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16285:1: ( ruleNamedTemplateBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16285:1: ( ruleNamedTemplateBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16286:1: ruleNamedTemplateBinding

+            {

+             before(grammarAccess.getTemplateBindingAccess().getBindingsNamedTemplateBindingParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleNamedTemplateBinding_in_rule__TemplateBinding__BindingsAssignment_133060);

+            ruleNamedTemplateBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getTemplateBindingAccess().getBindingsNamedTemplateBindingParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__BindingsAssignment_1"

+

+

+    // $ANTLR start "rule__TemplateBinding__BindingsAssignment_2_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16295:1: rule__TemplateBinding__BindingsAssignment_2_1 : ( ruleNamedTemplateBinding ) ;

+    public final void rule__TemplateBinding__BindingsAssignment_2_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16299:1: ( ( ruleNamedTemplateBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16300:1: ( ruleNamedTemplateBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16300:1: ( ruleNamedTemplateBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16301:1: ruleNamedTemplateBinding

+            {

+             before(grammarAccess.getTemplateBindingAccess().getBindingsNamedTemplateBindingParserRuleCall_2_1_0()); 

+            pushFollow(FOLLOW_ruleNamedTemplateBinding_in_rule__TemplateBinding__BindingsAssignment_2_133091);

+            ruleNamedTemplateBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getTemplateBindingAccess().getBindingsNamedTemplateBindingParserRuleCall_2_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TemplateBinding__BindingsAssignment_2_1"

+

+

+    // $ANTLR start "rule__NamedTemplateBinding__FormalAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16310:1: rule__NamedTemplateBinding__FormalAssignment_0 : ( RULE_ID ) ;

+    public final void rule__NamedTemplateBinding__FormalAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16314:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16315:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16315:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16316:1: RULE_ID

+            {

+             before(grammarAccess.getNamedTemplateBindingAccess().getFormalIDTerminalRuleCall_0_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__NamedTemplateBinding__FormalAssignment_033122); 

+             after(grammarAccess.getNamedTemplateBindingAccess().getFormalIDTerminalRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NamedTemplateBinding__FormalAssignment_0"

+

+

+    // $ANTLR start "rule__NamedTemplateBinding__ActualAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16325:1: rule__NamedTemplateBinding__ActualAssignment_2 : ( ruleQualifiedNameWithBinding ) ;

+    public final void rule__NamedTemplateBinding__ActualAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16329:1: ( ( ruleQualifiedNameWithBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16330:1: ( ruleQualifiedNameWithBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16330:1: ( ruleQualifiedNameWithBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16331:1: ruleQualifiedNameWithBinding

+            {

+             before(grammarAccess.getNamedTemplateBindingAccess().getActualQualifiedNameWithBindingParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNameWithBinding_in_rule__NamedTemplateBinding__ActualAssignment_233153);

+            ruleQualifiedNameWithBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getNamedTemplateBindingAccess().getActualQualifiedNameWithBindingParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NamedTemplateBinding__ActualAssignment_2"

+

+

+    // $ANTLR start "rule__QualifiedNameWithBinding__IdAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16340:1: rule__QualifiedNameWithBinding__IdAssignment_0 : ( RULE_ID ) ;

+    public final void rule__QualifiedNameWithBinding__IdAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16344:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16345:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16345:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16346:1: RULE_ID

+            {

+             before(grammarAccess.getQualifiedNameWithBindingAccess().getIdIDTerminalRuleCall_0_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__QualifiedNameWithBinding__IdAssignment_033184); 

+             after(grammarAccess.getQualifiedNameWithBindingAccess().getIdIDTerminalRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameWithBinding__IdAssignment_0"

+

+

+    // $ANTLR start "rule__QualifiedNameWithBinding__BindingAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16355:1: rule__QualifiedNameWithBinding__BindingAssignment_1 : ( ruleTemplateBinding ) ;

+    public final void rule__QualifiedNameWithBinding__BindingAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16359:1: ( ( ruleTemplateBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16360:1: ( ruleTemplateBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16360:1: ( ruleTemplateBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16361:1: ruleTemplateBinding

+            {

+             before(grammarAccess.getQualifiedNameWithBindingAccess().getBindingTemplateBindingParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleTemplateBinding_in_rule__QualifiedNameWithBinding__BindingAssignment_133215);

+            ruleTemplateBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getQualifiedNameWithBindingAccess().getBindingTemplateBindingParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameWithBinding__BindingAssignment_1"

+

+

+    // $ANTLR start "rule__QualifiedNameWithBinding__RemainingAssignment_2_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16370:1: rule__QualifiedNameWithBinding__RemainingAssignment_2_1 : ( ruleQualifiedNameWithBinding ) ;

+    public final void rule__QualifiedNameWithBinding__RemainingAssignment_2_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16374:1: ( ( ruleQualifiedNameWithBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16375:1: ( ruleQualifiedNameWithBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16375:1: ( ruleQualifiedNameWithBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16376:1: ruleQualifiedNameWithBinding

+            {

+             before(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingQualifiedNameWithBindingParserRuleCall_2_1_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNameWithBinding_in_rule__QualifiedNameWithBinding__RemainingAssignment_2_133246);

+            ruleQualifiedNameWithBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getQualifiedNameWithBindingAccess().getRemainingQualifiedNameWithBindingParserRuleCall_2_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameWithBinding__RemainingAssignment_2_1"

+

+

+    // $ANTLR start "rule__Tuple__TupleElementsAssignment_2_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16385:1: rule__Tuple__TupleElementsAssignment_2_0 : ( ruleTupleElement ) ;

+    public final void rule__Tuple__TupleElementsAssignment_2_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16389:1: ( ( ruleTupleElement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16390:1: ( ruleTupleElement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16390:1: ( ruleTupleElement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16391:1: ruleTupleElement

+            {

+             before(grammarAccess.getTupleAccess().getTupleElementsTupleElementParserRuleCall_2_0_0()); 

+            pushFollow(FOLLOW_ruleTupleElement_in_rule__Tuple__TupleElementsAssignment_2_033277);

+            ruleTupleElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getTupleAccess().getTupleElementsTupleElementParserRuleCall_2_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__TupleElementsAssignment_2_0"

+

+

+    // $ANTLR start "rule__Tuple__TupleElementsAssignment_2_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16400:1: rule__Tuple__TupleElementsAssignment_2_1_1 : ( ruleTupleElement ) ;

+    public final void rule__Tuple__TupleElementsAssignment_2_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16404:1: ( ( ruleTupleElement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16405:1: ( ruleTupleElement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16405:1: ( ruleTupleElement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16406:1: ruleTupleElement

+            {

+             before(grammarAccess.getTupleAccess().getTupleElementsTupleElementParserRuleCall_2_1_1_0()); 

+            pushFollow(FOLLOW_ruleTupleElement_in_rule__Tuple__TupleElementsAssignment_2_1_133308);

+            ruleTupleElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getTupleAccess().getTupleElementsTupleElementParserRuleCall_2_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Tuple__TupleElementsAssignment_2_1_1"

+

+

+    // $ANTLR start "rule__TupleElement__ArgumentAssignment"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16415:1: rule__TupleElement__ArgumentAssignment : ( ruleExpression ) ;

+    public final void rule__TupleElement__ArgumentAssignment() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16419:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16420:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16420:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16421:1: ruleExpression

+            {

+             before(grammarAccess.getTupleElementAccess().getArgumentExpressionParserRuleCall_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__TupleElement__ArgumentAssignment33339);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getTupleElementAccess().getArgumentExpressionParserRuleCall_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__TupleElement__ArgumentAssignment"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__ExpAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16430:1: rule__ConditionalTestExpression__ExpAssignment_0 : ( ruleConditionalOrExpression ) ;

+    public final void rule__ConditionalTestExpression__ExpAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16434:1: ( ( ruleConditionalOrExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16435:1: ( ruleConditionalOrExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16435:1: ( ruleConditionalOrExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16436:1: ruleConditionalOrExpression

+            {

+             before(grammarAccess.getConditionalTestExpressionAccess().getExpConditionalOrExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleConditionalOrExpression_in_rule__ConditionalTestExpression__ExpAssignment_033370);

+            ruleConditionalOrExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getConditionalTestExpressionAccess().getExpConditionalOrExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__ExpAssignment_0"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__WhenTrueAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16445:1: rule__ConditionalTestExpression__WhenTrueAssignment_1_1 : ( ruleConditionalTestExpression ) ;

+    public final void rule__ConditionalTestExpression__WhenTrueAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16449:1: ( ( ruleConditionalTestExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16450:1: ( ruleConditionalTestExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16450:1: ( ruleConditionalTestExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16451:1: ruleConditionalTestExpression

+            {

+             before(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueConditionalTestExpressionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleConditionalTestExpression_in_rule__ConditionalTestExpression__WhenTrueAssignment_1_133401);

+            ruleConditionalTestExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getConditionalTestExpressionAccess().getWhenTrueConditionalTestExpressionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__WhenTrueAssignment_1_1"

+

+

+    // $ANTLR start "rule__ConditionalTestExpression__WhenFalseAssignment_1_3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16460:1: rule__ConditionalTestExpression__WhenFalseAssignment_1_3 : ( ruleConditionalTestExpression ) ;

+    public final void rule__ConditionalTestExpression__WhenFalseAssignment_1_3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16464:1: ( ( ruleConditionalTestExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16465:1: ( ruleConditionalTestExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16465:1: ( ruleConditionalTestExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16466:1: ruleConditionalTestExpression

+            {

+             before(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseConditionalTestExpressionParserRuleCall_1_3_0()); 

+            pushFollow(FOLLOW_ruleConditionalTestExpression_in_rule__ConditionalTestExpression__WhenFalseAssignment_1_333432);

+            ruleConditionalTestExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getConditionalTestExpressionAccess().getWhenFalseConditionalTestExpressionParserRuleCall_1_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalTestExpression__WhenFalseAssignment_1_3"

+

+

+    // $ANTLR start "rule__ConditionalOrExpression__ExpAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16475:1: rule__ConditionalOrExpression__ExpAssignment_0 : ( ruleConditionalAndExpression ) ;

+    public final void rule__ConditionalOrExpression__ExpAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16479:1: ( ( ruleConditionalAndExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16480:1: ( ruleConditionalAndExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16480:1: ( ruleConditionalAndExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16481:1: ruleConditionalAndExpression

+            {

+             before(grammarAccess.getConditionalOrExpressionAccess().getExpConditionalAndExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleConditionalAndExpression_in_rule__ConditionalOrExpression__ExpAssignment_033463);

+            ruleConditionalAndExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getConditionalOrExpressionAccess().getExpConditionalAndExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalOrExpression__ExpAssignment_0"

+

+

+    // $ANTLR start "rule__ConditionalOrExpression__ExpAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16490:1: rule__ConditionalOrExpression__ExpAssignment_1_1 : ( ruleConditionalAndExpression ) ;

+    public final void rule__ConditionalOrExpression__ExpAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16494:1: ( ( ruleConditionalAndExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16495:1: ( ruleConditionalAndExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16495:1: ( ruleConditionalAndExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16496:1: ruleConditionalAndExpression

+            {

+             before(grammarAccess.getConditionalOrExpressionAccess().getExpConditionalAndExpressionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleConditionalAndExpression_in_rule__ConditionalOrExpression__ExpAssignment_1_133494);

+            ruleConditionalAndExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getConditionalOrExpressionAccess().getExpConditionalAndExpressionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalOrExpression__ExpAssignment_1_1"

+

+

+    // $ANTLR start "rule__ConditionalAndExpression__ExpAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16505:1: rule__ConditionalAndExpression__ExpAssignment_0 : ( ruleInclusiveOrExpression ) ;

+    public final void rule__ConditionalAndExpression__ExpAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16509:1: ( ( ruleInclusiveOrExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16510:1: ( ruleInclusiveOrExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16510:1: ( ruleInclusiveOrExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16511:1: ruleInclusiveOrExpression

+            {

+             before(grammarAccess.getConditionalAndExpressionAccess().getExpInclusiveOrExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleInclusiveOrExpression_in_rule__ConditionalAndExpression__ExpAssignment_033525);

+            ruleInclusiveOrExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getConditionalAndExpressionAccess().getExpInclusiveOrExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalAndExpression__ExpAssignment_0"

+

+

+    // $ANTLR start "rule__ConditionalAndExpression__ExpAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16520:1: rule__ConditionalAndExpression__ExpAssignment_1_1 : ( ruleInclusiveOrExpression ) ;

+    public final void rule__ConditionalAndExpression__ExpAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16524:1: ( ( ruleInclusiveOrExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16525:1: ( ruleInclusiveOrExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16525:1: ( ruleInclusiveOrExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16526:1: ruleInclusiveOrExpression

+            {

+             before(grammarAccess.getConditionalAndExpressionAccess().getExpInclusiveOrExpressionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleInclusiveOrExpression_in_rule__ConditionalAndExpression__ExpAssignment_1_133556);

+            ruleInclusiveOrExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getConditionalAndExpressionAccess().getExpInclusiveOrExpressionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConditionalAndExpression__ExpAssignment_1_1"

+

+

+    // $ANTLR start "rule__InclusiveOrExpression__ExpAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16535:1: rule__InclusiveOrExpression__ExpAssignment_0 : ( ruleExclusiveOrExpression ) ;

+    public final void rule__InclusiveOrExpression__ExpAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16539:1: ( ( ruleExclusiveOrExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16540:1: ( ruleExclusiveOrExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16540:1: ( ruleExclusiveOrExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16541:1: ruleExclusiveOrExpression

+            {

+             before(grammarAccess.getInclusiveOrExpressionAccess().getExpExclusiveOrExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleExclusiveOrExpression_in_rule__InclusiveOrExpression__ExpAssignment_033587);

+            ruleExclusiveOrExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getInclusiveOrExpressionAccess().getExpExclusiveOrExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InclusiveOrExpression__ExpAssignment_0"

+

+

+    // $ANTLR start "rule__InclusiveOrExpression__ExpAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16550:1: rule__InclusiveOrExpression__ExpAssignment_1_1 : ( ruleExclusiveOrExpression ) ;

+    public final void rule__InclusiveOrExpression__ExpAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16554:1: ( ( ruleExclusiveOrExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16555:1: ( ruleExclusiveOrExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16555:1: ( ruleExclusiveOrExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16556:1: ruleExclusiveOrExpression

+            {

+             before(grammarAccess.getInclusiveOrExpressionAccess().getExpExclusiveOrExpressionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleExclusiveOrExpression_in_rule__InclusiveOrExpression__ExpAssignment_1_133618);

+            ruleExclusiveOrExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getInclusiveOrExpressionAccess().getExpExclusiveOrExpressionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InclusiveOrExpression__ExpAssignment_1_1"

+

+

+    // $ANTLR start "rule__ExclusiveOrExpression__ExpAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16565:1: rule__ExclusiveOrExpression__ExpAssignment_0 : ( ruleAndExpression ) ;

+    public final void rule__ExclusiveOrExpression__ExpAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16569:1: ( ( ruleAndExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16570:1: ( ruleAndExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16570:1: ( ruleAndExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16571:1: ruleAndExpression

+            {

+             before(grammarAccess.getExclusiveOrExpressionAccess().getExpAndExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleAndExpression_in_rule__ExclusiveOrExpression__ExpAssignment_033649);

+            ruleAndExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getExclusiveOrExpressionAccess().getExpAndExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ExclusiveOrExpression__ExpAssignment_0"

+

+

+    // $ANTLR start "rule__ExclusiveOrExpression__ExpAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16580:1: rule__ExclusiveOrExpression__ExpAssignment_1_1 : ( ruleAndExpression ) ;

+    public final void rule__ExclusiveOrExpression__ExpAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16584:1: ( ( ruleAndExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16585:1: ( ruleAndExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16585:1: ( ruleAndExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16586:1: ruleAndExpression

+            {

+             before(grammarAccess.getExclusiveOrExpressionAccess().getExpAndExpressionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleAndExpression_in_rule__ExclusiveOrExpression__ExpAssignment_1_133680);

+            ruleAndExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getExclusiveOrExpressionAccess().getExpAndExpressionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ExclusiveOrExpression__ExpAssignment_1_1"

+

+

+    // $ANTLR start "rule__AndExpression__ExpAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16595:1: rule__AndExpression__ExpAssignment_0 : ( ruleEqualityExpression ) ;

+    public final void rule__AndExpression__ExpAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16599:1: ( ( ruleEqualityExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16600:1: ( ruleEqualityExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16600:1: ( ruleEqualityExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16601:1: ruleEqualityExpression

+            {

+             before(grammarAccess.getAndExpressionAccess().getExpEqualityExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleEqualityExpression_in_rule__AndExpression__ExpAssignment_033711);

+            ruleEqualityExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getAndExpressionAccess().getExpEqualityExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AndExpression__ExpAssignment_0"

+

+

+    // $ANTLR start "rule__AndExpression__ExpAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16610:1: rule__AndExpression__ExpAssignment_1_1 : ( ruleEqualityExpression ) ;

+    public final void rule__AndExpression__ExpAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16614:1: ( ( ruleEqualityExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16615:1: ( ruleEqualityExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16615:1: ( ruleEqualityExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16616:1: ruleEqualityExpression

+            {

+             before(grammarAccess.getAndExpressionAccess().getExpEqualityExpressionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleEqualityExpression_in_rule__AndExpression__ExpAssignment_1_133742);

+            ruleEqualityExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getAndExpressionAccess().getExpEqualityExpressionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AndExpression__ExpAssignment_1_1"

+

+

+    // $ANTLR start "rule__EqualityExpression__ExpAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16625:1: rule__EqualityExpression__ExpAssignment_0 : ( ruleClassificationExpression ) ;

+    public final void rule__EqualityExpression__ExpAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16629:1: ( ( ruleClassificationExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16630:1: ( ruleClassificationExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16630:1: ( ruleClassificationExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16631:1: ruleClassificationExpression

+            {

+             before(grammarAccess.getEqualityExpressionAccess().getExpClassificationExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleClassificationExpression_in_rule__EqualityExpression__ExpAssignment_033773);

+            ruleClassificationExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getEqualityExpressionAccess().getExpClassificationExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EqualityExpression__ExpAssignment_0"

+

+

+    // $ANTLR start "rule__EqualityExpression__OpAssignment_1_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16640:1: rule__EqualityExpression__OpAssignment_1_0 : ( ( rule__EqualityExpression__OpAlternatives_1_0_0 ) ) ;

+    public final void rule__EqualityExpression__OpAssignment_1_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16644:1: ( ( ( rule__EqualityExpression__OpAlternatives_1_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16645:1: ( ( rule__EqualityExpression__OpAlternatives_1_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16645:1: ( ( rule__EqualityExpression__OpAlternatives_1_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16646:1: ( rule__EqualityExpression__OpAlternatives_1_0_0 )

+            {

+             before(grammarAccess.getEqualityExpressionAccess().getOpAlternatives_1_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16647:1: ( rule__EqualityExpression__OpAlternatives_1_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16647:2: rule__EqualityExpression__OpAlternatives_1_0_0

+            {

+            pushFollow(FOLLOW_rule__EqualityExpression__OpAlternatives_1_0_0_in_rule__EqualityExpression__OpAssignment_1_033804);

+            rule__EqualityExpression__OpAlternatives_1_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getEqualityExpressionAccess().getOpAlternatives_1_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EqualityExpression__OpAssignment_1_0"

+

+

+    // $ANTLR start "rule__EqualityExpression__ExpAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16656:1: rule__EqualityExpression__ExpAssignment_1_1 : ( ruleClassificationExpression ) ;

+    public final void rule__EqualityExpression__ExpAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16660:1: ( ( ruleClassificationExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16661:1: ( ruleClassificationExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16661:1: ( ruleClassificationExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16662:1: ruleClassificationExpression

+            {

+             before(grammarAccess.getEqualityExpressionAccess().getExpClassificationExpressionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleClassificationExpression_in_rule__EqualityExpression__ExpAssignment_1_133837);

+            ruleClassificationExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getEqualityExpressionAccess().getExpClassificationExpressionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__EqualityExpression__ExpAssignment_1_1"

+

+

+    // $ANTLR start "rule__ClassificationExpression__ExpAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16671:1: rule__ClassificationExpression__ExpAssignment_0 : ( ruleRelationalExpression ) ;

+    public final void rule__ClassificationExpression__ExpAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16675:1: ( ( ruleRelationalExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16676:1: ( ruleRelationalExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16676:1: ( ruleRelationalExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16677:1: ruleRelationalExpression

+            {

+             before(grammarAccess.getClassificationExpressionAccess().getExpRelationalExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleRelationalExpression_in_rule__ClassificationExpression__ExpAssignment_033868);

+            ruleRelationalExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassificationExpressionAccess().getExpRelationalExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationExpression__ExpAssignment_0"

+

+

+    // $ANTLR start "rule__ClassificationExpression__OpAssignment_1_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16686:1: rule__ClassificationExpression__OpAssignment_1_0 : ( ( rule__ClassificationExpression__OpAlternatives_1_0_0 ) ) ;

+    public final void rule__ClassificationExpression__OpAssignment_1_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16690:1: ( ( ( rule__ClassificationExpression__OpAlternatives_1_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16691:1: ( ( rule__ClassificationExpression__OpAlternatives_1_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16691:1: ( ( rule__ClassificationExpression__OpAlternatives_1_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16692:1: ( rule__ClassificationExpression__OpAlternatives_1_0_0 )

+            {

+             before(grammarAccess.getClassificationExpressionAccess().getOpAlternatives_1_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16693:1: ( rule__ClassificationExpression__OpAlternatives_1_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16693:2: rule__ClassificationExpression__OpAlternatives_1_0_0

+            {

+            pushFollow(FOLLOW_rule__ClassificationExpression__OpAlternatives_1_0_0_in_rule__ClassificationExpression__OpAssignment_1_033899);

+            rule__ClassificationExpression__OpAlternatives_1_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getClassificationExpressionAccess().getOpAlternatives_1_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationExpression__OpAssignment_1_0"

+

+

+    // $ANTLR start "rule__ClassificationExpression__TypeNameAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16702:1: rule__ClassificationExpression__TypeNameAssignment_1_1 : ( ruleNameExpression ) ;

+    public final void rule__ClassificationExpression__TypeNameAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16706:1: ( ( ruleNameExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16707:1: ( ruleNameExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16707:1: ( ruleNameExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16708:1: ruleNameExpression

+            {

+             before(grammarAccess.getClassificationExpressionAccess().getTypeNameNameExpressionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleNameExpression_in_rule__ClassificationExpression__TypeNameAssignment_1_133932);

+            ruleNameExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassificationExpressionAccess().getTypeNameNameExpressionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationExpression__TypeNameAssignment_1_1"

+

+

+    // $ANTLR start "rule__RelationalExpression__LeftAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16717:1: rule__RelationalExpression__LeftAssignment_0 : ( ruleShiftExpression ) ;

+    public final void rule__RelationalExpression__LeftAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16721:1: ( ( ruleShiftExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16722:1: ( ruleShiftExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16722:1: ( ruleShiftExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16723:1: ruleShiftExpression

+            {

+             before(grammarAccess.getRelationalExpressionAccess().getLeftShiftExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleShiftExpression_in_rule__RelationalExpression__LeftAssignment_033963);

+            ruleShiftExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getRelationalExpressionAccess().getLeftShiftExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__RelationalExpression__LeftAssignment_0"

+

+

+    // $ANTLR start "rule__RelationalExpression__OpAssignment_1_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16732:1: rule__RelationalExpression__OpAssignment_1_0 : ( ( rule__RelationalExpression__OpAlternatives_1_0_0 ) ) ;

+    public final void rule__RelationalExpression__OpAssignment_1_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16736:1: ( ( ( rule__RelationalExpression__OpAlternatives_1_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16737:1: ( ( rule__RelationalExpression__OpAlternatives_1_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16737:1: ( ( rule__RelationalExpression__OpAlternatives_1_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16738:1: ( rule__RelationalExpression__OpAlternatives_1_0_0 )

+            {

+             before(grammarAccess.getRelationalExpressionAccess().getOpAlternatives_1_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16739:1: ( rule__RelationalExpression__OpAlternatives_1_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16739:2: rule__RelationalExpression__OpAlternatives_1_0_0

+            {

+            pushFollow(FOLLOW_rule__RelationalExpression__OpAlternatives_1_0_0_in_rule__RelationalExpression__OpAssignment_1_033994);

+            rule__RelationalExpression__OpAlternatives_1_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getRelationalExpressionAccess().getOpAlternatives_1_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__RelationalExpression__OpAssignment_1_0"

+

+

+    // $ANTLR start "rule__RelationalExpression__RightAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16748:1: rule__RelationalExpression__RightAssignment_1_1 : ( ruleShiftExpression ) ;

+    public final void rule__RelationalExpression__RightAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16752:1: ( ( ruleShiftExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16753:1: ( ruleShiftExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16753:1: ( ruleShiftExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16754:1: ruleShiftExpression

+            {

+             before(grammarAccess.getRelationalExpressionAccess().getRightShiftExpressionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleShiftExpression_in_rule__RelationalExpression__RightAssignment_1_134027);

+            ruleShiftExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getRelationalExpressionAccess().getRightShiftExpressionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__RelationalExpression__RightAssignment_1_1"

+

+

+    // $ANTLR start "rule__ShiftExpression__ExpAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16763:1: rule__ShiftExpression__ExpAssignment_0 : ( ruleAdditiveExpression ) ;

+    public final void rule__ShiftExpression__ExpAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16767:1: ( ( ruleAdditiveExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16768:1: ( ruleAdditiveExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16768:1: ( ruleAdditiveExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16769:1: ruleAdditiveExpression

+            {

+             before(grammarAccess.getShiftExpressionAccess().getExpAdditiveExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleAdditiveExpression_in_rule__ShiftExpression__ExpAssignment_034058);

+            ruleAdditiveExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getShiftExpressionAccess().getExpAdditiveExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ShiftExpression__ExpAssignment_0"

+

+

+    // $ANTLR start "rule__ShiftExpression__OpAssignment_1_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16778:1: rule__ShiftExpression__OpAssignment_1_0 : ( ( rule__ShiftExpression__OpAlternatives_1_0_0 ) ) ;

+    public final void rule__ShiftExpression__OpAssignment_1_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16782:1: ( ( ( rule__ShiftExpression__OpAlternatives_1_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16783:1: ( ( rule__ShiftExpression__OpAlternatives_1_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16783:1: ( ( rule__ShiftExpression__OpAlternatives_1_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16784:1: ( rule__ShiftExpression__OpAlternatives_1_0_0 )

+            {

+             before(grammarAccess.getShiftExpressionAccess().getOpAlternatives_1_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16785:1: ( rule__ShiftExpression__OpAlternatives_1_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16785:2: rule__ShiftExpression__OpAlternatives_1_0_0

+            {

+            pushFollow(FOLLOW_rule__ShiftExpression__OpAlternatives_1_0_0_in_rule__ShiftExpression__OpAssignment_1_034089);

+            rule__ShiftExpression__OpAlternatives_1_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getShiftExpressionAccess().getOpAlternatives_1_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ShiftExpression__OpAssignment_1_0"

+

+

+    // $ANTLR start "rule__ShiftExpression__ExpAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16794:1: rule__ShiftExpression__ExpAssignment_1_1 : ( ruleAdditiveExpression ) ;

+    public final void rule__ShiftExpression__ExpAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16798:1: ( ( ruleAdditiveExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16799:1: ( ruleAdditiveExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16799:1: ( ruleAdditiveExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16800:1: ruleAdditiveExpression

+            {

+             before(grammarAccess.getShiftExpressionAccess().getExpAdditiveExpressionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleAdditiveExpression_in_rule__ShiftExpression__ExpAssignment_1_134122);

+            ruleAdditiveExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getShiftExpressionAccess().getExpAdditiveExpressionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ShiftExpression__ExpAssignment_1_1"

+

+

+    // $ANTLR start "rule__AdditiveExpression__ExpAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16809:1: rule__AdditiveExpression__ExpAssignment_0 : ( ruleMultiplicativeExpression ) ;

+    public final void rule__AdditiveExpression__ExpAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16813:1: ( ( ruleMultiplicativeExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16814:1: ( ruleMultiplicativeExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16814:1: ( ruleMultiplicativeExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16815:1: ruleMultiplicativeExpression

+            {

+             before(grammarAccess.getAdditiveExpressionAccess().getExpMultiplicativeExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleMultiplicativeExpression_in_rule__AdditiveExpression__ExpAssignment_034153);

+            ruleMultiplicativeExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getAdditiveExpressionAccess().getExpMultiplicativeExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AdditiveExpression__ExpAssignment_0"

+

+

+    // $ANTLR start "rule__AdditiveExpression__OpAssignment_1_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16824:1: rule__AdditiveExpression__OpAssignment_1_0 : ( ( rule__AdditiveExpression__OpAlternatives_1_0_0 ) ) ;

+    public final void rule__AdditiveExpression__OpAssignment_1_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16828:1: ( ( ( rule__AdditiveExpression__OpAlternatives_1_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16829:1: ( ( rule__AdditiveExpression__OpAlternatives_1_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16829:1: ( ( rule__AdditiveExpression__OpAlternatives_1_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16830:1: ( rule__AdditiveExpression__OpAlternatives_1_0_0 )

+            {

+             before(grammarAccess.getAdditiveExpressionAccess().getOpAlternatives_1_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16831:1: ( rule__AdditiveExpression__OpAlternatives_1_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16831:2: rule__AdditiveExpression__OpAlternatives_1_0_0

+            {

+            pushFollow(FOLLOW_rule__AdditiveExpression__OpAlternatives_1_0_0_in_rule__AdditiveExpression__OpAssignment_1_034184);

+            rule__AdditiveExpression__OpAlternatives_1_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getAdditiveExpressionAccess().getOpAlternatives_1_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AdditiveExpression__OpAssignment_1_0"

+

+

+    // $ANTLR start "rule__AdditiveExpression__ExpAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16840:1: rule__AdditiveExpression__ExpAssignment_1_1 : ( ruleMultiplicativeExpression ) ;

+    public final void rule__AdditiveExpression__ExpAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16844:1: ( ( ruleMultiplicativeExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16845:1: ( ruleMultiplicativeExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16845:1: ( ruleMultiplicativeExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16846:1: ruleMultiplicativeExpression

+            {

+             before(grammarAccess.getAdditiveExpressionAccess().getExpMultiplicativeExpressionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleMultiplicativeExpression_in_rule__AdditiveExpression__ExpAssignment_1_134217);

+            ruleMultiplicativeExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getAdditiveExpressionAccess().getExpMultiplicativeExpressionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AdditiveExpression__ExpAssignment_1_1"

+

+

+    // $ANTLR start "rule__MultiplicativeExpression__ExpAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16855:1: rule__MultiplicativeExpression__ExpAssignment_0 : ( ruleUnaryExpression ) ;

+    public final void rule__MultiplicativeExpression__ExpAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16859:1: ( ( ruleUnaryExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16860:1: ( ruleUnaryExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16860:1: ( ruleUnaryExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16861:1: ruleUnaryExpression

+            {

+             before(grammarAccess.getMultiplicativeExpressionAccess().getExpUnaryExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleUnaryExpression_in_rule__MultiplicativeExpression__ExpAssignment_034248);

+            ruleUnaryExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getMultiplicativeExpressionAccess().getExpUnaryExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__MultiplicativeExpression__ExpAssignment_0"

+

+

+    // $ANTLR start "rule__MultiplicativeExpression__OpAssignment_1_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16870:1: rule__MultiplicativeExpression__OpAssignment_1_0 : ( ( rule__MultiplicativeExpression__OpAlternatives_1_0_0 ) ) ;

+    public final void rule__MultiplicativeExpression__OpAssignment_1_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16874:1: ( ( ( rule__MultiplicativeExpression__OpAlternatives_1_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16875:1: ( ( rule__MultiplicativeExpression__OpAlternatives_1_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16875:1: ( ( rule__MultiplicativeExpression__OpAlternatives_1_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16876:1: ( rule__MultiplicativeExpression__OpAlternatives_1_0_0 )

+            {

+             before(grammarAccess.getMultiplicativeExpressionAccess().getOpAlternatives_1_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16877:1: ( rule__MultiplicativeExpression__OpAlternatives_1_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16877:2: rule__MultiplicativeExpression__OpAlternatives_1_0_0

+            {

+            pushFollow(FOLLOW_rule__MultiplicativeExpression__OpAlternatives_1_0_0_in_rule__MultiplicativeExpression__OpAssignment_1_034279);

+            rule__MultiplicativeExpression__OpAlternatives_1_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getMultiplicativeExpressionAccess().getOpAlternatives_1_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__MultiplicativeExpression__OpAssignment_1_0"

+

+

+    // $ANTLR start "rule__MultiplicativeExpression__ExpAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16886:1: rule__MultiplicativeExpression__ExpAssignment_1_1 : ( ruleUnaryExpression ) ;

+    public final void rule__MultiplicativeExpression__ExpAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16890:1: ( ( ruleUnaryExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16891:1: ( ruleUnaryExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16891:1: ( ruleUnaryExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16892:1: ruleUnaryExpression

+            {

+             before(grammarAccess.getMultiplicativeExpressionAccess().getExpUnaryExpressionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleUnaryExpression_in_rule__MultiplicativeExpression__ExpAssignment_1_134312);

+            ruleUnaryExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getMultiplicativeExpressionAccess().getExpUnaryExpressionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__MultiplicativeExpression__ExpAssignment_1_1"

+

+

+    // $ANTLR start "rule__UnaryExpression__OpAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16901:1: rule__UnaryExpression__OpAssignment_0 : ( ( rule__UnaryExpression__OpAlternatives_0_0 ) ) ;

+    public final void rule__UnaryExpression__OpAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16905:1: ( ( ( rule__UnaryExpression__OpAlternatives_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16906:1: ( ( rule__UnaryExpression__OpAlternatives_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16906:1: ( ( rule__UnaryExpression__OpAlternatives_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16907:1: ( rule__UnaryExpression__OpAlternatives_0_0 )

+            {

+             before(grammarAccess.getUnaryExpressionAccess().getOpAlternatives_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16908:1: ( rule__UnaryExpression__OpAlternatives_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16908:2: rule__UnaryExpression__OpAlternatives_0_0

+            {

+            pushFollow(FOLLOW_rule__UnaryExpression__OpAlternatives_0_0_in_rule__UnaryExpression__OpAssignment_034343);

+            rule__UnaryExpression__OpAlternatives_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getUnaryExpressionAccess().getOpAlternatives_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UnaryExpression__OpAssignment_0"

+

+

+    // $ANTLR start "rule__UnaryExpression__ExpAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16917:1: rule__UnaryExpression__ExpAssignment_1 : ( rulePrimaryExpression ) ;

+    public final void rule__UnaryExpression__ExpAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16921:1: ( ( rulePrimaryExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16922:1: ( rulePrimaryExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16922:1: ( rulePrimaryExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16923:1: rulePrimaryExpression

+            {

+             before(grammarAccess.getUnaryExpressionAccess().getExpPrimaryExpressionParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_rulePrimaryExpression_in_rule__UnaryExpression__ExpAssignment_134376);

+            rulePrimaryExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getUnaryExpressionAccess().getExpPrimaryExpressionParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__UnaryExpression__ExpAssignment_1"

+

+

+    // $ANTLR start "rule__PrimaryExpression__PrefixAssignment"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16932:1: rule__PrimaryExpression__PrefixAssignment : ( ruleValueSpecification ) ;

+    public final void rule__PrimaryExpression__PrefixAssignment() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16936:1: ( ( ruleValueSpecification ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16937:1: ( ruleValueSpecification )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16937:1: ( ruleValueSpecification )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16938:1: ruleValueSpecification

+            {

+             before(grammarAccess.getPrimaryExpressionAccess().getPrefixValueSpecificationParserRuleCall_0()); 

+            pushFollow(FOLLOW_ruleValueSpecification_in_rule__PrimaryExpression__PrefixAssignment34407);

+            ruleValueSpecification();

+

+            state._fsp--;

+

+             after(grammarAccess.getPrimaryExpressionAccess().getPrefixValueSpecificationParserRuleCall_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PrimaryExpression__PrefixAssignment"

+

+

+    // $ANTLR start "rule__OperationCallExpression__OperationNameAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16947:1: rule__OperationCallExpression__OperationNameAssignment_1 : ( RULE_ID ) ;

+    public final void rule__OperationCallExpression__OperationNameAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16951:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16952:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16952:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16953:1: RULE_ID

+            {

+             before(grammarAccess.getOperationCallExpressionAccess().getOperationNameIDTerminalRuleCall_1_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__OperationCallExpression__OperationNameAssignment_134438); 

+             after(grammarAccess.getOperationCallExpressionAccess().getOperationNameIDTerminalRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__OperationCallExpression__OperationNameAssignment_1"

+

+

+    // $ANTLR start "rule__OperationCallExpression__TupleAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16962:1: rule__OperationCallExpression__TupleAssignment_2 : ( ruleTuple ) ;

+    public final void rule__OperationCallExpression__TupleAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16966:1: ( ( ruleTuple ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16967:1: ( ruleTuple )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16967:1: ( ruleTuple )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16968:1: ruleTuple

+            {

+             before(grammarAccess.getOperationCallExpressionAccess().getTupleTupleParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleTuple_in_rule__OperationCallExpression__TupleAssignment_234469);

+            ruleTuple();

+

+            state._fsp--;

+

+             after(grammarAccess.getOperationCallExpressionAccess().getTupleTupleParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__OperationCallExpression__TupleAssignment_2"

+

+

+    // $ANTLR start "rule__OperationCallExpression__SuffixAssignment_3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16977:1: rule__OperationCallExpression__SuffixAssignment_3 : ( ruleSuffixExpression ) ;

+    public final void rule__OperationCallExpression__SuffixAssignment_3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16981:1: ( ( ruleSuffixExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16982:1: ( ruleSuffixExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16982:1: ( ruleSuffixExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16983:1: ruleSuffixExpression

+            {

+             before(grammarAccess.getOperationCallExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); 

+            pushFollow(FOLLOW_ruleSuffixExpression_in_rule__OperationCallExpression__SuffixAssignment_334500);

+            ruleSuffixExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getOperationCallExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__OperationCallExpression__SuffixAssignment_3"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__PropertyNameAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16992:1: rule__PropertyCallExpression__PropertyNameAssignment_1 : ( RULE_ID ) ;

+    public final void rule__PropertyCallExpression__PropertyNameAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16996:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16997:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16997:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:16998:1: RULE_ID

+            {

+             before(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameIDTerminalRuleCall_1_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__PropertyCallExpression__PropertyNameAssignment_134531); 

+             after(grammarAccess.getPropertyCallExpressionAccess().getPropertyNameIDTerminalRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__PropertyNameAssignment_1"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__IndexAssignment_2_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17007:1: rule__PropertyCallExpression__IndexAssignment_2_1 : ( ruleExpression ) ;

+    public final void rule__PropertyCallExpression__IndexAssignment_2_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17011:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17012:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17012:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17013:1: ruleExpression

+            {

+             before(grammarAccess.getPropertyCallExpressionAccess().getIndexExpressionParserRuleCall_2_1_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__PropertyCallExpression__IndexAssignment_2_134562);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getPropertyCallExpressionAccess().getIndexExpressionParserRuleCall_2_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__IndexAssignment_2_1"

+

+

+    // $ANTLR start "rule__PropertyCallExpression__SuffixAssignment_3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17022:1: rule__PropertyCallExpression__SuffixAssignment_3 : ( ruleSuffixExpression ) ;

+    public final void rule__PropertyCallExpression__SuffixAssignment_3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17026:1: ( ( ruleSuffixExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17027:1: ( ruleSuffixExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17027:1: ( ruleSuffixExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17028:1: ruleSuffixExpression

+            {

+             before(grammarAccess.getPropertyCallExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); 

+            pushFollow(FOLLOW_ruleSuffixExpression_in_rule__PropertyCallExpression__SuffixAssignment_334593);

+            ruleSuffixExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getPropertyCallExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PropertyCallExpression__SuffixAssignment_3"

+

+

+    // $ANTLR start "rule__LinkOperationExpression__KindAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17037:1: rule__LinkOperationExpression__KindAssignment_1 : ( ruleLinkOperationKind ) ;

+    public final void rule__LinkOperationExpression__KindAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17041:1: ( ( ruleLinkOperationKind ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17042:1: ( ruleLinkOperationKind )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17042:1: ( ruleLinkOperationKind )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17043:1: ruleLinkOperationKind

+            {

+             before(grammarAccess.getLinkOperationExpressionAccess().getKindLinkOperationKindEnumRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleLinkOperationKind_in_rule__LinkOperationExpression__KindAssignment_134624);

+            ruleLinkOperationKind();

+

+            state._fsp--;

+

+             after(grammarAccess.getLinkOperationExpressionAccess().getKindLinkOperationKindEnumRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationExpression__KindAssignment_1"

+

+

+    // $ANTLR start "rule__LinkOperationExpression__TupleAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17052:1: rule__LinkOperationExpression__TupleAssignment_2 : ( ruleLinkOperationTuple ) ;

+    public final void rule__LinkOperationExpression__TupleAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17056:1: ( ( ruleLinkOperationTuple ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17057:1: ( ruleLinkOperationTuple )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17057:1: ( ruleLinkOperationTuple )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17058:1: ruleLinkOperationTuple

+            {

+             before(grammarAccess.getLinkOperationExpressionAccess().getTupleLinkOperationTupleParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleLinkOperationTuple_in_rule__LinkOperationExpression__TupleAssignment_234655);

+            ruleLinkOperationTuple();

+

+            state._fsp--;

+

+             after(grammarAccess.getLinkOperationExpressionAccess().getTupleLinkOperationTupleParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationExpression__TupleAssignment_2"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17067:1: rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1 : ( ruleLinkOperationTupleElement ) ;

+    public final void rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17071:1: ( ( ruleLinkOperationTupleElement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17072:1: ( ruleLinkOperationTupleElement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17072:1: ( ruleLinkOperationTupleElement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17073:1: ruleLinkOperationTupleElement

+            {

+             before(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementLinkOperationTupleElementParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleLinkOperationTupleElement_in_rule__LinkOperationTuple__LinkOperationTupleElementAssignment_134686);

+            ruleLinkOperationTupleElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementLinkOperationTupleElementParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1"

+

+

+    // $ANTLR start "rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17082:1: rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1 : ( ruleLinkOperationTupleElement ) ;

+    public final void rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17086:1: ( ( ruleLinkOperationTupleElement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17087:1: ( ruleLinkOperationTupleElement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17087:1: ( ruleLinkOperationTupleElement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17088:1: ruleLinkOperationTupleElement

+            {

+             before(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementLinkOperationTupleElementParserRuleCall_2_1_0()); 

+            pushFollow(FOLLOW_ruleLinkOperationTupleElement_in_rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_134717);

+            ruleLinkOperationTupleElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getLinkOperationTupleAccess().getLinkOperationTupleElementLinkOperationTupleElementParserRuleCall_2_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__RoleAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17097:1: rule__LinkOperationTupleElement__RoleAssignment_0 : ( RULE_ID ) ;

+    public final void rule__LinkOperationTupleElement__RoleAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17101:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17102:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17102:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17103:1: RULE_ID

+            {

+             before(grammarAccess.getLinkOperationTupleElementAccess().getRoleIDTerminalRuleCall_0_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__LinkOperationTupleElement__RoleAssignment_034748); 

+             after(grammarAccess.getLinkOperationTupleElementAccess().getRoleIDTerminalRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__RoleAssignment_0"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__RoleIndexAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17112:1: rule__LinkOperationTupleElement__RoleIndexAssignment_1_1 : ( ruleExpression ) ;

+    public final void rule__LinkOperationTupleElement__RoleIndexAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17116:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17117:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17117:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17118:1: ruleExpression

+            {

+             before(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexExpressionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__LinkOperationTupleElement__RoleIndexAssignment_1_134779);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getLinkOperationTupleElementAccess().getRoleIndexExpressionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__RoleIndexAssignment_1_1"

+

+

+    // $ANTLR start "rule__LinkOperationTupleElement__ObjectAssignment_3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17127:1: rule__LinkOperationTupleElement__ObjectAssignment_3 : ( ruleExpression ) ;

+    public final void rule__LinkOperationTupleElement__ObjectAssignment_3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17131:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17132:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17132:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17133:1: ruleExpression

+            {

+             before(grammarAccess.getLinkOperationTupleElementAccess().getObjectExpressionParserRuleCall_3_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__LinkOperationTupleElement__ObjectAssignment_334810);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getLinkOperationTupleElementAccess().getObjectExpressionParserRuleCall_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LinkOperationTupleElement__ObjectAssignment_3"

+

+

+    // $ANTLR start "rule__SequenceOperationExpression__OperationNameAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17142:1: rule__SequenceOperationExpression__OperationNameAssignment_1 : ( ruleQualifiedNameWithBinding ) ;

+    public final void rule__SequenceOperationExpression__OperationNameAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17146:1: ( ( ruleQualifiedNameWithBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17147:1: ( ruleQualifiedNameWithBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17147:1: ( ruleQualifiedNameWithBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17148:1: ruleQualifiedNameWithBinding

+            {

+             before(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameQualifiedNameWithBindingParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNameWithBinding_in_rule__SequenceOperationExpression__OperationNameAssignment_134841);

+            ruleQualifiedNameWithBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceOperationExpressionAccess().getOperationNameQualifiedNameWithBindingParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceOperationExpression__OperationNameAssignment_1"

+

+

+    // $ANTLR start "rule__SequenceOperationExpression__TupleAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17157:1: rule__SequenceOperationExpression__TupleAssignment_2 : ( ruleTuple ) ;

+    public final void rule__SequenceOperationExpression__TupleAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17161:1: ( ( ruleTuple ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17162:1: ( ruleTuple )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17162:1: ( ruleTuple )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17163:1: ruleTuple

+            {

+             before(grammarAccess.getSequenceOperationExpressionAccess().getTupleTupleParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleTuple_in_rule__SequenceOperationExpression__TupleAssignment_234872);

+            ruleTuple();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceOperationExpressionAccess().getTupleTupleParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceOperationExpression__TupleAssignment_2"

+

+

+    // $ANTLR start "rule__SequenceOperationExpression__SuffixAssignment_3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17172:1: rule__SequenceOperationExpression__SuffixAssignment_3 : ( ruleSuffixExpression ) ;

+    public final void rule__SequenceOperationExpression__SuffixAssignment_3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17176:1: ( ( ruleSuffixExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17177:1: ( ruleSuffixExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17177:1: ( ruleSuffixExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17178:1: ruleSuffixExpression

+            {

+             before(grammarAccess.getSequenceOperationExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); 

+            pushFollow(FOLLOW_ruleSuffixExpression_in_rule__SequenceOperationExpression__SuffixAssignment_334903);

+            ruleSuffixExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceOperationExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceOperationExpression__SuffixAssignment_3"

+

+

+    // $ANTLR start "rule__SequenceReductionExpression__IsOrderedAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17187:1: rule__SequenceReductionExpression__IsOrderedAssignment_2 : ( ( 'ordered' ) ) ;

+    public final void rule__SequenceReductionExpression__IsOrderedAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17191:1: ( ( ( 'ordered' ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17192:1: ( ( 'ordered' ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17192:1: ( ( 'ordered' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17193:1: ( 'ordered' )

+            {

+             before(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedOrderedKeyword_2_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17194:1: ( 'ordered' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17195:1: 'ordered'

+            {

+             before(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedOrderedKeyword_2_0()); 

+            match(input,113,FOLLOW_113_in_rule__SequenceReductionExpression__IsOrderedAssignment_234939); 

+             after(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedOrderedKeyword_2_0()); 

+

+            }

+

+             after(grammarAccess.getSequenceReductionExpressionAccess().getIsOrderedOrderedKeyword_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceReductionExpression__IsOrderedAssignment_2"

+

+

+    // $ANTLR start "rule__SequenceReductionExpression__BehaviorAssignment_3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17210:1: rule__SequenceReductionExpression__BehaviorAssignment_3 : ( ruleQualifiedNameWithBinding ) ;

+    public final void rule__SequenceReductionExpression__BehaviorAssignment_3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17214:1: ( ( ruleQualifiedNameWithBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17215:1: ( ruleQualifiedNameWithBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17215:1: ( ruleQualifiedNameWithBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17216:1: ruleQualifiedNameWithBinding

+            {

+             before(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorQualifiedNameWithBindingParserRuleCall_3_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNameWithBinding_in_rule__SequenceReductionExpression__BehaviorAssignment_334978);

+            ruleQualifiedNameWithBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceReductionExpressionAccess().getBehaviorQualifiedNameWithBindingParserRuleCall_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceReductionExpression__BehaviorAssignment_3"

+

+

+    // $ANTLR start "rule__SequenceReductionExpression__SuffixAssignment_4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17225:1: rule__SequenceReductionExpression__SuffixAssignment_4 : ( ruleSuffixExpression ) ;

+    public final void rule__SequenceReductionExpression__SuffixAssignment_4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17229:1: ( ( ruleSuffixExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17230:1: ( ruleSuffixExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17230:1: ( ruleSuffixExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17231:1: ruleSuffixExpression

+            {

+             before(grammarAccess.getSequenceReductionExpressionAccess().getSuffixSuffixExpressionParserRuleCall_4_0()); 

+            pushFollow(FOLLOW_ruleSuffixExpression_in_rule__SequenceReductionExpression__SuffixAssignment_435009);

+            ruleSuffixExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceReductionExpressionAccess().getSuffixSuffixExpressionParserRuleCall_4_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceReductionExpression__SuffixAssignment_4"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__OpAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17240:1: rule__SelectOrRejectOperation__OpAssignment_1 : ( ruleSelectOrRejectOperator ) ;

+    public final void rule__SelectOrRejectOperation__OpAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17244:1: ( ( ruleSelectOrRejectOperator ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17245:1: ( ruleSelectOrRejectOperator )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17245:1: ( ruleSelectOrRejectOperator )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17246:1: ruleSelectOrRejectOperator

+            {

+             before(grammarAccess.getSelectOrRejectOperationAccess().getOpSelectOrRejectOperatorEnumRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleSelectOrRejectOperator_in_rule__SelectOrRejectOperation__OpAssignment_135040);

+            ruleSelectOrRejectOperator();

+

+            state._fsp--;

+

+             after(grammarAccess.getSelectOrRejectOperationAccess().getOpSelectOrRejectOperatorEnumRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__OpAssignment_1"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__NameAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17255:1: rule__SelectOrRejectOperation__NameAssignment_2 : ( RULE_ID ) ;

+    public final void rule__SelectOrRejectOperation__NameAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17259:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17260:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17260:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17261:1: RULE_ID

+            {

+             before(grammarAccess.getSelectOrRejectOperationAccess().getNameIDTerminalRuleCall_2_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__SelectOrRejectOperation__NameAssignment_235071); 

+             after(grammarAccess.getSelectOrRejectOperationAccess().getNameIDTerminalRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__NameAssignment_2"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__ExprAssignment_4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17270:1: rule__SelectOrRejectOperation__ExprAssignment_4 : ( ruleExpression ) ;

+    public final void rule__SelectOrRejectOperation__ExprAssignment_4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17274:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17275:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17275:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17276:1: ruleExpression

+            {

+             before(grammarAccess.getSelectOrRejectOperationAccess().getExprExpressionParserRuleCall_4_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__SelectOrRejectOperation__ExprAssignment_435102);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSelectOrRejectOperationAccess().getExprExpressionParserRuleCall_4_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__ExprAssignment_4"

+

+

+    // $ANTLR start "rule__SelectOrRejectOperation__SuffixAssignment_6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17285:1: rule__SelectOrRejectOperation__SuffixAssignment_6 : ( ruleSuffixExpression ) ;

+    public final void rule__SelectOrRejectOperation__SuffixAssignment_6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17289:1: ( ( ruleSuffixExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17290:1: ( ruleSuffixExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17290:1: ( ruleSuffixExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17291:1: ruleSuffixExpression

+            {

+             before(grammarAccess.getSelectOrRejectOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); 

+            pushFollow(FOLLOW_ruleSuffixExpression_in_rule__SelectOrRejectOperation__SuffixAssignment_635133);

+            ruleSuffixExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSelectOrRejectOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SelectOrRejectOperation__SuffixAssignment_6"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__OpAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17300:1: rule__CollectOrIterateOperation__OpAssignment_1 : ( ruleCollectOrIterateOperator ) ;

+    public final void rule__CollectOrIterateOperation__OpAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17304:1: ( ( ruleCollectOrIterateOperator ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17305:1: ( ruleCollectOrIterateOperator )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17305:1: ( ruleCollectOrIterateOperator )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17306:1: ruleCollectOrIterateOperator

+            {

+             before(grammarAccess.getCollectOrIterateOperationAccess().getOpCollectOrIterateOperatorEnumRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleCollectOrIterateOperator_in_rule__CollectOrIterateOperation__OpAssignment_135164);

+            ruleCollectOrIterateOperator();

+

+            state._fsp--;

+

+             after(grammarAccess.getCollectOrIterateOperationAccess().getOpCollectOrIterateOperatorEnumRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__OpAssignment_1"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__NameAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17315:1: rule__CollectOrIterateOperation__NameAssignment_2 : ( RULE_ID ) ;

+    public final void rule__CollectOrIterateOperation__NameAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17319:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17320:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17320:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17321:1: RULE_ID

+            {

+             before(grammarAccess.getCollectOrIterateOperationAccess().getNameIDTerminalRuleCall_2_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__CollectOrIterateOperation__NameAssignment_235195); 

+             after(grammarAccess.getCollectOrIterateOperationAccess().getNameIDTerminalRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__NameAssignment_2"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__ExprAssignment_4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17330:1: rule__CollectOrIterateOperation__ExprAssignment_4 : ( ruleExpression ) ;

+    public final void rule__CollectOrIterateOperation__ExprAssignment_4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17334:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17335:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17335:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17336:1: ruleExpression

+            {

+             before(grammarAccess.getCollectOrIterateOperationAccess().getExprExpressionParserRuleCall_4_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__CollectOrIterateOperation__ExprAssignment_435226);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getCollectOrIterateOperationAccess().getExprExpressionParserRuleCall_4_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__ExprAssignment_4"

+

+

+    // $ANTLR start "rule__CollectOrIterateOperation__SuffixAssignment_6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17345:1: rule__CollectOrIterateOperation__SuffixAssignment_6 : ( ruleSuffixExpression ) ;

+    public final void rule__CollectOrIterateOperation__SuffixAssignment_6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17349:1: ( ( ruleSuffixExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17350:1: ( ruleSuffixExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17350:1: ( ruleSuffixExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17351:1: ruleSuffixExpression

+            {

+             before(grammarAccess.getCollectOrIterateOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); 

+            pushFollow(FOLLOW_ruleSuffixExpression_in_rule__CollectOrIterateOperation__SuffixAssignment_635257);

+            ruleSuffixExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getCollectOrIterateOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CollectOrIterateOperation__SuffixAssignment_6"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__OpAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17360:1: rule__ForAllOrExistsOrOneOperation__OpAssignment_1 : ( ruleForAllOrExistsOrOneOperator ) ;

+    public final void rule__ForAllOrExistsOrOneOperation__OpAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17364:1: ( ( ruleForAllOrExistsOrOneOperator ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17365:1: ( ruleForAllOrExistsOrOneOperator )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17365:1: ( ruleForAllOrExistsOrOneOperator )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17366:1: ruleForAllOrExistsOrOneOperator

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpForAllOrExistsOrOneOperatorEnumRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleForAllOrExistsOrOneOperator_in_rule__ForAllOrExistsOrOneOperation__OpAssignment_135288);

+            ruleForAllOrExistsOrOneOperator();

+

+            state._fsp--;

+

+             after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getOpForAllOrExistsOrOneOperatorEnumRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__OpAssignment_1"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__NameAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17375:1: rule__ForAllOrExistsOrOneOperation__NameAssignment_2 : ( RULE_ID ) ;

+    public final void rule__ForAllOrExistsOrOneOperation__NameAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17379:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17380:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17380:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17381:1: RULE_ID

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameIDTerminalRuleCall_2_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__ForAllOrExistsOrOneOperation__NameAssignment_235319); 

+             after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getNameIDTerminalRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__NameAssignment_2"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__ExprAssignment_4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17390:1: rule__ForAllOrExistsOrOneOperation__ExprAssignment_4 : ( ruleExpression ) ;

+    public final void rule__ForAllOrExistsOrOneOperation__ExprAssignment_4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17394:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17395:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17395:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17396:1: ruleExpression

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprExpressionParserRuleCall_4_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__ForAllOrExistsOrOneOperation__ExprAssignment_435350);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getExprExpressionParserRuleCall_4_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__ExprAssignment_4"

+

+

+    // $ANTLR start "rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17405:1: rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6 : ( ruleSuffixExpression ) ;

+    public final void rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17409:1: ( ( ruleSuffixExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17410:1: ( ruleSuffixExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17410:1: ( ruleSuffixExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17411:1: ruleSuffixExpression

+            {

+             before(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); 

+            pushFollow(FOLLOW_ruleSuffixExpression_in_rule__ForAllOrExistsOrOneOperation__SuffixAssignment_635381);

+            ruleSuffixExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getForAllOrExistsOrOneOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__NameAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17420:1: rule__IsUniqueOperation__NameAssignment_2 : ( RULE_ID ) ;

+    public final void rule__IsUniqueOperation__NameAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17424:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17425:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17425:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17426:1: RULE_ID

+            {

+             before(grammarAccess.getIsUniqueOperationAccess().getNameIDTerminalRuleCall_2_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__IsUniqueOperation__NameAssignment_235412); 

+             after(grammarAccess.getIsUniqueOperationAccess().getNameIDTerminalRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__NameAssignment_2"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__ExprAssignment_4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17435:1: rule__IsUniqueOperation__ExprAssignment_4 : ( ruleExpression ) ;

+    public final void rule__IsUniqueOperation__ExprAssignment_4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17439:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17440:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17440:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17441:1: ruleExpression

+            {

+             before(grammarAccess.getIsUniqueOperationAccess().getExprExpressionParserRuleCall_4_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__IsUniqueOperation__ExprAssignment_435443);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getIsUniqueOperationAccess().getExprExpressionParserRuleCall_4_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__ExprAssignment_4"

+

+

+    // $ANTLR start "rule__IsUniqueOperation__SuffixAssignment_6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17450:1: rule__IsUniqueOperation__SuffixAssignment_6 : ( ruleSuffixExpression ) ;

+    public final void rule__IsUniqueOperation__SuffixAssignment_6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17454:1: ( ( ruleSuffixExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17455:1: ( ruleSuffixExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17455:1: ( ruleSuffixExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17456:1: ruleSuffixExpression

+            {

+             before(grammarAccess.getIsUniqueOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); 

+            pushFollow(FOLLOW_ruleSuffixExpression_in_rule__IsUniqueOperation__SuffixAssignment_635474);

+            ruleSuffixExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getIsUniqueOperationAccess().getSuffixSuffixExpressionParserRuleCall_6_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IsUniqueOperation__SuffixAssignment_6"

+

+

+    // $ANTLR start "rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17465:1: rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1 : ( ruleExpression ) ;

+    public final void rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17469:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17470:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17470:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17471:1: ruleExpression

+            {

+             before(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastExpressionParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__ParenthesizedExpression__ExpOrTypeCastAssignment_135505);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getParenthesizedExpressionAccess().getExpOrTypeCastExpressionParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1"

+

+

+    // $ANTLR start "rule__ParenthesizedExpression__CastedAssignment_3_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17480:1: rule__ParenthesizedExpression__CastedAssignment_3_0 : ( ruleNonLiteralValueSpecification ) ;

+    public final void rule__ParenthesizedExpression__CastedAssignment_3_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17484:1: ( ( ruleNonLiteralValueSpecification ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17485:1: ( ruleNonLiteralValueSpecification )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17485:1: ( ruleNonLiteralValueSpecification )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17486:1: ruleNonLiteralValueSpecification

+            {

+             before(grammarAccess.getParenthesizedExpressionAccess().getCastedNonLiteralValueSpecificationParserRuleCall_3_0_0()); 

+            pushFollow(FOLLOW_ruleNonLiteralValueSpecification_in_rule__ParenthesizedExpression__CastedAssignment_3_035536);

+            ruleNonLiteralValueSpecification();

+

+            state._fsp--;

+

+             after(grammarAccess.getParenthesizedExpressionAccess().getCastedNonLiteralValueSpecificationParserRuleCall_3_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ParenthesizedExpression__CastedAssignment_3_0"

+

+

+    // $ANTLR start "rule__ParenthesizedExpression__SuffixAssignment_3_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17495:1: rule__ParenthesizedExpression__SuffixAssignment_3_1 : ( ruleSuffixExpression ) ;

+    public final void rule__ParenthesizedExpression__SuffixAssignment_3_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17499:1: ( ( ruleSuffixExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17500:1: ( ruleSuffixExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17500:1: ( ruleSuffixExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17501:1: ruleSuffixExpression

+            {

+             before(grammarAccess.getParenthesizedExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_1_0()); 

+            pushFollow(FOLLOW_ruleSuffixExpression_in_rule__ParenthesizedExpression__SuffixAssignment_3_135567);

+            ruleSuffixExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getParenthesizedExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ParenthesizedExpression__SuffixAssignment_3_1"

+

+

+    // $ANTLR start "rule__ThisExpression__SuffixAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17510:1: rule__ThisExpression__SuffixAssignment_2 : ( ruleSuffixExpression ) ;

+    public final void rule__ThisExpression__SuffixAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17514:1: ( ( ruleSuffixExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17515:1: ( ruleSuffixExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17515:1: ( ruleSuffixExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17516:1: ruleSuffixExpression

+            {

+             before(grammarAccess.getThisExpressionAccess().getSuffixSuffixExpressionParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleSuffixExpression_in_rule__ThisExpression__SuffixAssignment_235598);

+            ruleSuffixExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getThisExpressionAccess().getSuffixSuffixExpressionParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisExpression__SuffixAssignment_2"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__TupleAssignment_1_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17525:1: rule__SuperInvocationExpression__TupleAssignment_1_0 : ( ruleTuple ) ;

+    public final void rule__SuperInvocationExpression__TupleAssignment_1_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17529:1: ( ( ruleTuple ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17530:1: ( ruleTuple )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17530:1: ( ruleTuple )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17531:1: ruleTuple

+            {

+             before(grammarAccess.getSuperInvocationExpressionAccess().getTupleTupleParserRuleCall_1_0_0()); 

+            pushFollow(FOLLOW_ruleTuple_in_rule__SuperInvocationExpression__TupleAssignment_1_035629);

+            ruleTuple();

+

+            state._fsp--;

+

+             after(grammarAccess.getSuperInvocationExpressionAccess().getTupleTupleParserRuleCall_1_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__TupleAssignment_1_0"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__OperationNameAssignment_1_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17540:1: rule__SuperInvocationExpression__OperationNameAssignment_1_1_1 : ( ruleQualifiedNameWithBinding ) ;

+    public final void rule__SuperInvocationExpression__OperationNameAssignment_1_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17544:1: ( ( ruleQualifiedNameWithBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17545:1: ( ruleQualifiedNameWithBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17545:1: ( ruleQualifiedNameWithBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17546:1: ruleQualifiedNameWithBinding

+            {

+             before(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameQualifiedNameWithBindingParserRuleCall_1_1_1_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNameWithBinding_in_rule__SuperInvocationExpression__OperationNameAssignment_1_1_135660);

+            ruleQualifiedNameWithBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getSuperInvocationExpressionAccess().getOperationNameQualifiedNameWithBindingParserRuleCall_1_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__OperationNameAssignment_1_1_1"

+

+

+    // $ANTLR start "rule__SuperInvocationExpression__TupleAssignment_1_1_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17555:1: rule__SuperInvocationExpression__TupleAssignment_1_1_2 : ( ruleTuple ) ;

+    public final void rule__SuperInvocationExpression__TupleAssignment_1_1_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17559:1: ( ( ruleTuple ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17560:1: ( ruleTuple )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17560:1: ( ruleTuple )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17561:1: ruleTuple

+            {

+             before(grammarAccess.getSuperInvocationExpressionAccess().getTupleTupleParserRuleCall_1_1_2_0()); 

+            pushFollow(FOLLOW_ruleTuple_in_rule__SuperInvocationExpression__TupleAssignment_1_1_235691);

+            ruleTuple();

+

+            state._fsp--;

+

+             after(grammarAccess.getSuperInvocationExpressionAccess().getTupleTupleParserRuleCall_1_1_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationExpression__TupleAssignment_1_1_2"

+

+

+    // $ANTLR start "rule__InstanceCreationExpression__ConstructorAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17570:1: rule__InstanceCreationExpression__ConstructorAssignment_1 : ( ruleQualifiedNameWithBinding ) ;

+    public final void rule__InstanceCreationExpression__ConstructorAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17574:1: ( ( ruleQualifiedNameWithBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17575:1: ( ruleQualifiedNameWithBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17575:1: ( ruleQualifiedNameWithBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17576:1: ruleQualifiedNameWithBinding

+            {

+             before(grammarAccess.getInstanceCreationExpressionAccess().getConstructorQualifiedNameWithBindingParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNameWithBinding_in_rule__InstanceCreationExpression__ConstructorAssignment_135722);

+            ruleQualifiedNameWithBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getInstanceCreationExpressionAccess().getConstructorQualifiedNameWithBindingParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationExpression__ConstructorAssignment_1"

+

+

+    // $ANTLR start "rule__InstanceCreationExpression__TupleAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17585:1: rule__InstanceCreationExpression__TupleAssignment_2 : ( ruleInstanceCreationTuple ) ;

+    public final void rule__InstanceCreationExpression__TupleAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17589:1: ( ( ruleInstanceCreationTuple ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17590:1: ( ruleInstanceCreationTuple )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17590:1: ( ruleInstanceCreationTuple )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17591:1: ruleInstanceCreationTuple

+            {

+             before(grammarAccess.getInstanceCreationExpressionAccess().getTupleInstanceCreationTupleParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleInstanceCreationTuple_in_rule__InstanceCreationExpression__TupleAssignment_235753);

+            ruleInstanceCreationTuple();

+

+            state._fsp--;

+

+             after(grammarAccess.getInstanceCreationExpressionAccess().getTupleInstanceCreationTupleParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationExpression__TupleAssignment_2"

+

+

+    // $ANTLR start "rule__InstanceCreationExpression__SuffixAssignment_3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17600:1: rule__InstanceCreationExpression__SuffixAssignment_3 : ( ruleSuffixExpression ) ;

+    public final void rule__InstanceCreationExpression__SuffixAssignment_3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17604:1: ( ( ruleSuffixExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17605:1: ( ruleSuffixExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17605:1: ( ruleSuffixExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17606:1: ruleSuffixExpression

+            {

+             before(grammarAccess.getInstanceCreationExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); 

+            pushFollow(FOLLOW_ruleSuffixExpression_in_rule__InstanceCreationExpression__SuffixAssignment_335784);

+            ruleSuffixExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getInstanceCreationExpressionAccess().getSuffixSuffixExpressionParserRuleCall_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationExpression__SuffixAssignment_3"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17615:1: rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0 : ( ruleInstanceCreationTupleElement ) ;

+    public final void rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17619:1: ( ( ruleInstanceCreationTupleElement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17620:1: ( ruleInstanceCreationTupleElement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17620:1: ( ruleInstanceCreationTupleElement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17621:1: ruleInstanceCreationTupleElement

+            {

+             before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementInstanceCreationTupleElementParserRuleCall_2_0_0()); 

+            pushFollow(FOLLOW_ruleInstanceCreationTupleElement_in_rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_035815);

+            ruleInstanceCreationTupleElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementInstanceCreationTupleElementParserRuleCall_2_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0"

+

+

+    // $ANTLR start "rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17630:1: rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1 : ( ruleInstanceCreationTupleElement ) ;

+    public final void rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17634:1: ( ( ruleInstanceCreationTupleElement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17635:1: ( ruleInstanceCreationTupleElement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17635:1: ( ruleInstanceCreationTupleElement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17636:1: ruleInstanceCreationTupleElement

+            {

+             before(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementInstanceCreationTupleElementParserRuleCall_2_1_1_0()); 

+            pushFollow(FOLLOW_ruleInstanceCreationTupleElement_in_rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_135846);

+            ruleInstanceCreationTupleElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getInstanceCreationTupleAccess().getInstanceCreationTupleElementInstanceCreationTupleElementParserRuleCall_2_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1"

+

+

+    // $ANTLR start "rule__InstanceCreationTupleElement__RoleAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17645:1: rule__InstanceCreationTupleElement__RoleAssignment_0 : ( RULE_ID ) ;

+    public final void rule__InstanceCreationTupleElement__RoleAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17649:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17650:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17650:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17651:1: RULE_ID

+            {

+             before(grammarAccess.getInstanceCreationTupleElementAccess().getRoleIDTerminalRuleCall_0_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__InstanceCreationTupleElement__RoleAssignment_035877); 

+             after(grammarAccess.getInstanceCreationTupleElementAccess().getRoleIDTerminalRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTupleElement__RoleAssignment_0"

+

+

+    // $ANTLR start "rule__InstanceCreationTupleElement__ObjectAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17660:1: rule__InstanceCreationTupleElement__ObjectAssignment_2 : ( ruleExpression ) ;

+    public final void rule__InstanceCreationTupleElement__ObjectAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17664:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17665:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17665:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17666:1: ruleExpression

+            {

+             before(grammarAccess.getInstanceCreationTupleElementAccess().getObjectExpressionParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__InstanceCreationTupleElement__ObjectAssignment_235908);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getInstanceCreationTupleElementAccess().getObjectExpressionParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationTupleElement__ObjectAssignment_2"

+

+

+    // $ANTLR start "rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17675:1: rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0 : ( ( '[' ) ) ;

+    public final void rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17679:1: ( ( ( '[' ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17680:1: ( ( '[' ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17680:1: ( ( '[' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17681:1: ( '[' )

+            {

+             before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17682:1: ( '[' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17683:1: '['

+            {

+             before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); 

+            match(input,78,FOLLOW_78_in_rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_035944); 

+             after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); 

+

+            }

+

+             after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0"

+

+

+    // $ANTLR start "rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17698:1: rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0 : ( ruleAccessCompletion ) ;

+    public final void rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17702:1: ( ( ruleAccessCompletion ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17703:1: ( ruleAccessCompletion )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17703:1: ( ruleAccessCompletion )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17704:1: ruleAccessCompletion

+            {

+             before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAccessCompletionParserRuleCall_0_1_0_0()); 

+            pushFollow(FOLLOW_ruleAccessCompletion_in_rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_035983);

+            ruleAccessCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getAccessCompletionAccessCompletionParserRuleCall_0_1_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0"

+

+

+    // $ANTLR start "rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17713:1: rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1 : ( rulePartialSequenceConstructionCompletion ) ;

+    public final void rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17717:1: ( ( rulePartialSequenceConstructionCompletion ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17718:1: ( rulePartialSequenceConstructionCompletion )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17718:1: ( rulePartialSequenceConstructionCompletion )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17719:1: rulePartialSequenceConstructionCompletion

+            {

+             before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionPartialSequenceConstructionCompletionParserRuleCall_0_1_1_0()); 

+            pushFollow(FOLLOW_rulePartialSequenceConstructionCompletion_in_rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_136014);

+            rulePartialSequenceConstructionCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getSequenceCompletionPartialSequenceConstructionCompletionParserRuleCall_0_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1"

+

+

+    // $ANTLR start "rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17728:1: rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1 : ( ruleSequenceConstructionExpression ) ;

+    public final void rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17732:1: ( ( ruleSequenceConstructionExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17733:1: ( ruleSequenceConstructionExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17733:1: ( ruleSequenceConstructionExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17734:1: ruleSequenceConstructionExpression

+            {

+             before(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionSequenceConstructionExpressionParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleSequenceConstructionExpression_in_rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_136045);

+            ruleSequenceConstructionExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceConstructionOrAccessCompletionAccess().getExpressionSequenceConstructionExpressionParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1"

+

+

+    // $ANTLR start "rule__AccessCompletion__AccessIndexAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17743:1: rule__AccessCompletion__AccessIndexAssignment_0 : ( ruleExpression ) ;

+    public final void rule__AccessCompletion__AccessIndexAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17747:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17748:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17748:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17749:1: ruleExpression

+            {

+             before(grammarAccess.getAccessCompletionAccess().getAccessIndexExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__AccessCompletion__AccessIndexAssignment_036076);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getAccessCompletionAccess().getAccessIndexExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AccessCompletion__AccessIndexAssignment_0"

+

+

+    // $ANTLR start "rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17758:1: rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1 : ( ruleSequenceConstructionExpression ) ;

+    public final void rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17762:1: ( ( ruleSequenceConstructionExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17763:1: ( ruleSequenceConstructionExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17763:1: ( ruleSequenceConstructionExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17764:1: ruleSequenceConstructionExpression

+            {

+             before(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionSequenceConstructionExpressionParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleSequenceConstructionExpression_in_rule__PartialSequenceConstructionCompletion__ExpressionAssignment_136107);

+            ruleSequenceConstructionExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getPartialSequenceConstructionCompletionAccess().getExpressionSequenceConstructionExpressionParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__SequenceElementAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17773:1: rule__SequenceConstructionExpression__SequenceElementAssignment_1 : ( ruleSequenceElement ) ;

+    public final void rule__SequenceConstructionExpression__SequenceElementAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17777:1: ( ( ruleSequenceElement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17778:1: ( ruleSequenceElement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17778:1: ( ruleSequenceElement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17779:1: ruleSequenceElement

+            {

+             before(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementSequenceElementParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleSequenceElement_in_rule__SequenceConstructionExpression__SequenceElementAssignment_136138);

+            ruleSequenceElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementSequenceElementParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__SequenceElementAssignment_1"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17788:1: rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1 : ( ruleSequenceElement ) ;

+    public final void rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17792:1: ( ( ruleSequenceElement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17793:1: ( ruleSequenceElement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17793:1: ( ruleSequenceElement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17794:1: ruleSequenceElement

+            {

+             before(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementSequenceElementParserRuleCall_2_0_1_0()); 

+            pushFollow(FOLLOW_ruleSequenceElement_in_rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_136169);

+            ruleSequenceElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceConstructionExpressionAccess().getSequenceElementSequenceElementParserRuleCall_2_0_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1"

+

+

+    // $ANTLR start "rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17803:1: rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1 : ( ruleExpression ) ;

+    public final void rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17807:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17808:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17808:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17809:1: ruleExpression

+            {

+             before(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperExpressionParserRuleCall_2_1_1_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_136200);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequenceConstructionExpressionAccess().getRangeUpperExpressionParserRuleCall_2_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1"

+

+

+    // $ANTLR start "rule__Block__SequenceAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17818:1: rule__Block__SequenceAssignment_2 : ( ruleStatementSequence ) ;

+    public final void rule__Block__SequenceAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17822:1: ( ( ruleStatementSequence ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17823:1: ( ruleStatementSequence )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17823:1: ( ruleStatementSequence )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17824:1: ruleStatementSequence

+            {

+             before(grammarAccess.getBlockAccess().getSequenceStatementSequenceParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleStatementSequence_in_rule__Block__SequenceAssignment_236231);

+            ruleStatementSequence();

+

+            state._fsp--;

+

+             after(grammarAccess.getBlockAccess().getSequenceStatementSequenceParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Block__SequenceAssignment_2"

+

+

+    // $ANTLR start "rule__StatementSequence__StatementsAssignment"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17833:1: rule__StatementSequence__StatementsAssignment : ( ruleDocumentedStatement ) ;

+    public final void rule__StatementSequence__StatementsAssignment() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17837:1: ( ( ruleDocumentedStatement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17838:1: ( ruleDocumentedStatement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17838:1: ( ruleDocumentedStatement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17839:1: ruleDocumentedStatement

+            {

+             before(grammarAccess.getStatementSequenceAccess().getStatementsDocumentedStatementParserRuleCall_0()); 

+            pushFollow(FOLLOW_ruleDocumentedStatement_in_rule__StatementSequence__StatementsAssignment36262);

+            ruleDocumentedStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getStatementSequenceAccess().getStatementsDocumentedStatementParserRuleCall_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__StatementSequence__StatementsAssignment"

+

+

+    // $ANTLR start "rule__DocumentedStatement__CommentAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17848:1: rule__DocumentedStatement__CommentAssignment_0 : ( ( rule__DocumentedStatement__CommentAlternatives_0_0 ) ) ;

+    public final void rule__DocumentedStatement__CommentAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17852:1: ( ( ( rule__DocumentedStatement__CommentAlternatives_0_0 ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17853:1: ( ( rule__DocumentedStatement__CommentAlternatives_0_0 ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17853:1: ( ( rule__DocumentedStatement__CommentAlternatives_0_0 ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17854:1: ( rule__DocumentedStatement__CommentAlternatives_0_0 )

+            {

+             before(grammarAccess.getDocumentedStatementAccess().getCommentAlternatives_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17855:1: ( rule__DocumentedStatement__CommentAlternatives_0_0 )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17855:2: rule__DocumentedStatement__CommentAlternatives_0_0

+            {

+            pushFollow(FOLLOW_rule__DocumentedStatement__CommentAlternatives_0_0_in_rule__DocumentedStatement__CommentAssignment_036293);

+            rule__DocumentedStatement__CommentAlternatives_0_0();

+

+            state._fsp--;

+

+

+            }

+

+             after(grammarAccess.getDocumentedStatementAccess().getCommentAlternatives_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DocumentedStatement__CommentAssignment_0"

+

+

+    // $ANTLR start "rule__DocumentedStatement__StatementAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17864:1: rule__DocumentedStatement__StatementAssignment_1 : ( ruleStatement ) ;

+    public final void rule__DocumentedStatement__StatementAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17868:1: ( ( ruleStatement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17869:1: ( ruleStatement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17869:1: ( ruleStatement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17870:1: ruleStatement

+            {

+             before(grammarAccess.getDocumentedStatementAccess().getStatementStatementParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleStatement_in_rule__DocumentedStatement__StatementAssignment_136326);

+            ruleStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getDocumentedStatementAccess().getStatementStatementParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DocumentedStatement__StatementAssignment_1"

+

+

+    // $ANTLR start "rule__InlineStatement__LangageNameAssignment_3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17879:1: rule__InlineStatement__LangageNameAssignment_3 : ( RULE_ID ) ;

+    public final void rule__InlineStatement__LangageNameAssignment_3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17883:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17884:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17884:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17885:1: RULE_ID

+            {

+             before(grammarAccess.getInlineStatementAccess().getLangageNameIDTerminalRuleCall_3_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__InlineStatement__LangageNameAssignment_336357); 

+             after(grammarAccess.getInlineStatementAccess().getLangageNameIDTerminalRuleCall_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__LangageNameAssignment_3"

+

+

+    // $ANTLR start "rule__InlineStatement__BodyAssignment_5"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17894:1: rule__InlineStatement__BodyAssignment_5 : ( RULE_STRING ) ;

+    public final void rule__InlineStatement__BodyAssignment_5() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17898:1: ( ( RULE_STRING ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17899:1: ( RULE_STRING )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17899:1: ( RULE_STRING )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17900:1: RULE_STRING

+            {

+             before(grammarAccess.getInlineStatementAccess().getBodySTRINGTerminalRuleCall_5_0()); 

+            match(input,RULE_STRING,FOLLOW_RULE_STRING_in_rule__InlineStatement__BodyAssignment_536388); 

+             after(grammarAccess.getInlineStatementAccess().getBodySTRINGTerminalRuleCall_5_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InlineStatement__BodyAssignment_5"

+

+

+    // $ANTLR start "rule__AnnotatedStatement__AnnotationAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17909:1: rule__AnnotatedStatement__AnnotationAssignment_1 : ( ruleAnnotation ) ;

+    public final void rule__AnnotatedStatement__AnnotationAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17913:1: ( ( ruleAnnotation ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17914:1: ( ruleAnnotation )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17914:1: ( ruleAnnotation )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17915:1: ruleAnnotation

+            {

+             before(grammarAccess.getAnnotatedStatementAccess().getAnnotationAnnotationParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleAnnotation_in_rule__AnnotatedStatement__AnnotationAssignment_136419);

+            ruleAnnotation();

+

+            state._fsp--;

+

+             after(grammarAccess.getAnnotatedStatementAccess().getAnnotationAnnotationParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AnnotatedStatement__AnnotationAssignment_1"

+

+

+    // $ANTLR start "rule__AnnotatedStatement__StatementAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17924:1: rule__AnnotatedStatement__StatementAssignment_2 : ( ruleStatement ) ;

+    public final void rule__AnnotatedStatement__StatementAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17928:1: ( ( ruleStatement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17929:1: ( ruleStatement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17929:1: ( ruleStatement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17930:1: ruleStatement

+            {

+             before(grammarAccess.getAnnotatedStatementAccess().getStatementStatementParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleStatement_in_rule__AnnotatedStatement__StatementAssignment_236450);

+            ruleStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getAnnotatedStatementAccess().getStatementStatementParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AnnotatedStatement__StatementAssignment_2"

+

+

+    // $ANTLR start "rule__Annotation__KindAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17939:1: rule__Annotation__KindAssignment_0 : ( ruleAnnotationKind ) ;

+    public final void rule__Annotation__KindAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17943:1: ( ( ruleAnnotationKind ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17944:1: ( ruleAnnotationKind )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17944:1: ( ruleAnnotationKind )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17945:1: ruleAnnotationKind

+            {

+             before(grammarAccess.getAnnotationAccess().getKindAnnotationKindEnumRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleAnnotationKind_in_rule__Annotation__KindAssignment_036481);

+            ruleAnnotationKind();

+

+            state._fsp--;

+

+             after(grammarAccess.getAnnotationAccess().getKindAnnotationKindEnumRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__KindAssignment_0"

+

+

+    // $ANTLR start "rule__Annotation__ArgsAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17954:1: rule__Annotation__ArgsAssignment_1_1 : ( RULE_ID ) ;

+    public final void rule__Annotation__ArgsAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17958:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17959:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17959:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17960:1: RULE_ID

+            {

+             before(grammarAccess.getAnnotationAccess().getArgsIDTerminalRuleCall_1_1_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__Annotation__ArgsAssignment_1_136512); 

+             after(grammarAccess.getAnnotationAccess().getArgsIDTerminalRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__ArgsAssignment_1_1"

+

+

+    // $ANTLR start "rule__Annotation__ArgsAssignment_1_2_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17969:1: rule__Annotation__ArgsAssignment_1_2_1 : ( RULE_ID ) ;

+    public final void rule__Annotation__ArgsAssignment_1_2_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17973:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17974:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17974:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17975:1: RULE_ID

+            {

+             before(grammarAccess.getAnnotationAccess().getArgsIDTerminalRuleCall_1_2_1_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__Annotation__ArgsAssignment_1_2_136543); 

+             after(grammarAccess.getAnnotationAccess().getArgsIDTerminalRuleCall_1_2_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__Annotation__ArgsAssignment_1_2_1"

+

+

+    // $ANTLR start "rule__BlockStatement__BlockAssignment"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17984:1: rule__BlockStatement__BlockAssignment : ( ruleBlock ) ;

+    public final void rule__BlockStatement__BlockAssignment() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17988:1: ( ( ruleBlock ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17989:1: ( ruleBlock )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17989:1: ( ruleBlock )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17990:1: ruleBlock

+            {

+             before(grammarAccess.getBlockStatementAccess().getBlockBlockParserRuleCall_0()); 

+            pushFollow(FOLLOW_ruleBlock_in_rule__BlockStatement__BlockAssignment36574);

+            ruleBlock();

+

+            state._fsp--;

+

+             after(grammarAccess.getBlockStatementAccess().getBlockBlockParserRuleCall_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__BlockStatement__BlockAssignment"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__VarNameAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:17999:1: rule__LocalNameDeclarationStatement__VarNameAssignment_1 : ( RULE_ID ) ;

+    public final void rule__LocalNameDeclarationStatement__VarNameAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18003:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18004:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18004:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18005:1: RULE_ID

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameIDTerminalRuleCall_1_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__LocalNameDeclarationStatement__VarNameAssignment_136605); 

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getVarNameIDTerminalRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__VarNameAssignment_1"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__TypeAssignment_3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18014:1: rule__LocalNameDeclarationStatement__TypeAssignment_3 : ( ruleQualifiedNameWithBinding ) ;

+    public final void rule__LocalNameDeclarationStatement__TypeAssignment_3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18018:1: ( ( ruleQualifiedNameWithBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18019:1: ( ruleQualifiedNameWithBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18019:1: ( ruleQualifiedNameWithBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18020:1: ruleQualifiedNameWithBinding

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeQualifiedNameWithBindingParserRuleCall_3_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNameWithBinding_in_rule__LocalNameDeclarationStatement__TypeAssignment_336636);

+            ruleQualifiedNameWithBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getTypeQualifiedNameWithBindingParserRuleCall_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__TypeAssignment_3"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18029:1: rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0 : ( ( '[' ) ) ;

+    public final void rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18033:1: ( ( ( '[' ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18034:1: ( ( '[' ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18034:1: ( ( '[' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18035:1: ( '[' )

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_4_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18036:1: ( '[' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18037:1: '['

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_4_0_0()); 

+            match(input,78,FOLLOW_78_in_rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_036672); 

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_4_0_0()); 

+

+            }

+

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_4_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0"

+

+

+    // $ANTLR start "rule__LocalNameDeclarationStatement__InitAssignment_6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18052:1: rule__LocalNameDeclarationStatement__InitAssignment_6 : ( ruleSequenceElement ) ;

+    public final void rule__LocalNameDeclarationStatement__InitAssignment_6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18056:1: ( ( ruleSequenceElement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18057:1: ( ruleSequenceElement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18057:1: ( ruleSequenceElement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18058:1: ruleSequenceElement

+            {

+             before(grammarAccess.getLocalNameDeclarationStatementAccess().getInitSequenceElementParserRuleCall_6_0()); 

+            pushFollow(FOLLOW_ruleSequenceElement_in_rule__LocalNameDeclarationStatement__InitAssignment_636711);

+            ruleSequenceElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getLocalNameDeclarationStatementAccess().getInitSequenceElementParserRuleCall_6_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LocalNameDeclarationStatement__InitAssignment_6"

+

+

+    // $ANTLR start "rule__IfStatement__SequentialClaussesAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18067:1: rule__IfStatement__SequentialClaussesAssignment_1 : ( ruleSequentialClauses ) ;

+    public final void rule__IfStatement__SequentialClaussesAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18071:1: ( ( ruleSequentialClauses ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18072:1: ( ruleSequentialClauses )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18072:1: ( ruleSequentialClauses )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18073:1: ruleSequentialClauses

+            {

+             before(grammarAccess.getIfStatementAccess().getSequentialClaussesSequentialClausesParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleSequentialClauses_in_rule__IfStatement__SequentialClaussesAssignment_136742);

+            ruleSequentialClauses();

+

+            state._fsp--;

+

+             after(grammarAccess.getIfStatementAccess().getSequentialClaussesSequentialClausesParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IfStatement__SequentialClaussesAssignment_1"

+

+

+    // $ANTLR start "rule__IfStatement__FinalClauseAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18082:1: rule__IfStatement__FinalClauseAssignment_2 : ( ruleFinalClause ) ;

+    public final void rule__IfStatement__FinalClauseAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18086:1: ( ( ruleFinalClause ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18087:1: ( ruleFinalClause )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18087:1: ( ruleFinalClause )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18088:1: ruleFinalClause

+            {

+             before(grammarAccess.getIfStatementAccess().getFinalClauseFinalClauseParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleFinalClause_in_rule__IfStatement__FinalClauseAssignment_236773);

+            ruleFinalClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getIfStatementAccess().getFinalClauseFinalClauseParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__IfStatement__FinalClauseAssignment_2"

+

+

+    // $ANTLR start "rule__SequentialClauses__ConccurentClausesAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18097:1: rule__SequentialClauses__ConccurentClausesAssignment_0 : ( ruleConcurrentClauses ) ;

+    public final void rule__SequentialClauses__ConccurentClausesAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18101:1: ( ( ruleConcurrentClauses ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18102:1: ( ruleConcurrentClauses )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18102:1: ( ruleConcurrentClauses )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18103:1: ruleConcurrentClauses

+            {

+             before(grammarAccess.getSequentialClausesAccess().getConccurentClausesConcurrentClausesParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleConcurrentClauses_in_rule__SequentialClauses__ConccurentClausesAssignment_036804);

+            ruleConcurrentClauses();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequentialClausesAccess().getConccurentClausesConcurrentClausesParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequentialClauses__ConccurentClausesAssignment_0"

+

+

+    // $ANTLR start "rule__SequentialClauses__ConccurentClausesAssignment_1_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18112:1: rule__SequentialClauses__ConccurentClausesAssignment_1_2 : ( ruleConcurrentClauses ) ;

+    public final void rule__SequentialClauses__ConccurentClausesAssignment_1_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18116:1: ( ( ruleConcurrentClauses ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18117:1: ( ruleConcurrentClauses )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18117:1: ( ruleConcurrentClauses )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18118:1: ruleConcurrentClauses

+            {

+             before(grammarAccess.getSequentialClausesAccess().getConccurentClausesConcurrentClausesParserRuleCall_1_2_0()); 

+            pushFollow(FOLLOW_ruleConcurrentClauses_in_rule__SequentialClauses__ConccurentClausesAssignment_1_236835);

+            ruleConcurrentClauses();

+

+            state._fsp--;

+

+             after(grammarAccess.getSequentialClausesAccess().getConccurentClausesConcurrentClausesParserRuleCall_1_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SequentialClauses__ConccurentClausesAssignment_1_2"

+

+

+    // $ANTLR start "rule__ConcurrentClauses__NonFinalClauseAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18127:1: rule__ConcurrentClauses__NonFinalClauseAssignment_0 : ( ruleNonFinalClause ) ;

+    public final void rule__ConcurrentClauses__NonFinalClauseAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18131:1: ( ( ruleNonFinalClause ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18132:1: ( ruleNonFinalClause )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18132:1: ( ruleNonFinalClause )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18133:1: ruleNonFinalClause

+            {

+             before(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleNonFinalClause_in_rule__ConcurrentClauses__NonFinalClauseAssignment_036866);

+            ruleNonFinalClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConcurrentClauses__NonFinalClauseAssignment_0"

+

+

+    // $ANTLR start "rule__ConcurrentClauses__NonFinalClauseAssignment_1_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18142:1: rule__ConcurrentClauses__NonFinalClauseAssignment_1_2 : ( ruleNonFinalClause ) ;

+    public final void rule__ConcurrentClauses__NonFinalClauseAssignment_1_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18146:1: ( ( ruleNonFinalClause ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18147:1: ( ruleNonFinalClause )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18147:1: ( ruleNonFinalClause )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18148:1: ruleNonFinalClause

+            {

+             before(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_1_2_0()); 

+            pushFollow(FOLLOW_ruleNonFinalClause_in_rule__ConcurrentClauses__NonFinalClauseAssignment_1_236897);

+            ruleNonFinalClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getConcurrentClausesAccess().getNonFinalClauseNonFinalClauseParserRuleCall_1_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ConcurrentClauses__NonFinalClauseAssignment_1_2"

+

+

+    // $ANTLR start "rule__NonFinalClause__ConditionAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18157:1: rule__NonFinalClause__ConditionAssignment_1 : ( ruleExpression ) ;

+    public final void rule__NonFinalClause__ConditionAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18161:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18162:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18162:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18163:1: ruleExpression

+            {

+             before(grammarAccess.getNonFinalClauseAccess().getConditionExpressionParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__NonFinalClause__ConditionAssignment_136928);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getNonFinalClauseAccess().getConditionExpressionParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NonFinalClause__ConditionAssignment_1"

+

+

+    // $ANTLR start "rule__NonFinalClause__BlockAssignment_3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18172:1: rule__NonFinalClause__BlockAssignment_3 : ( ruleBlock ) ;

+    public final void rule__NonFinalClause__BlockAssignment_3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18176:1: ( ( ruleBlock ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18177:1: ( ruleBlock )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18177:1: ( ruleBlock )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18178:1: ruleBlock

+            {

+             before(grammarAccess.getNonFinalClauseAccess().getBlockBlockParserRuleCall_3_0()); 

+            pushFollow(FOLLOW_ruleBlock_in_rule__NonFinalClause__BlockAssignment_336959);

+            ruleBlock();

+

+            state._fsp--;

+

+             after(grammarAccess.getNonFinalClauseAccess().getBlockBlockParserRuleCall_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NonFinalClause__BlockAssignment_3"

+

+

+    // $ANTLR start "rule__FinalClause__BlockAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18187:1: rule__FinalClause__BlockAssignment_1 : ( ruleBlock ) ;

+    public final void rule__FinalClause__BlockAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18191:1: ( ( ruleBlock ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18192:1: ( ruleBlock )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18192:1: ( ruleBlock )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18193:1: ruleBlock

+            {

+             before(grammarAccess.getFinalClauseAccess().getBlockBlockParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleBlock_in_rule__FinalClause__BlockAssignment_136990);

+            ruleBlock();

+

+            state._fsp--;

+

+             after(grammarAccess.getFinalClauseAccess().getBlockBlockParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__FinalClause__BlockAssignment_1"

+

+

+    // $ANTLR start "rule__SwitchStatement__ExpressionAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18202:1: rule__SwitchStatement__ExpressionAssignment_2 : ( ruleExpression ) ;

+    public final void rule__SwitchStatement__ExpressionAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18206:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18207:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18207:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18208:1: ruleExpression

+            {

+             before(grammarAccess.getSwitchStatementAccess().getExpressionExpressionParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__SwitchStatement__ExpressionAssignment_237021);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSwitchStatementAccess().getExpressionExpressionParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__ExpressionAssignment_2"

+

+

+    // $ANTLR start "rule__SwitchStatement__SwitchClauseAssignment_5"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18217:1: rule__SwitchStatement__SwitchClauseAssignment_5 : ( ruleSwitchClause ) ;

+    public final void rule__SwitchStatement__SwitchClauseAssignment_5() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18221:1: ( ( ruleSwitchClause ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18222:1: ( ruleSwitchClause )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18222:1: ( ruleSwitchClause )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18223:1: ruleSwitchClause

+            {

+             before(grammarAccess.getSwitchStatementAccess().getSwitchClauseSwitchClauseParserRuleCall_5_0()); 

+            pushFollow(FOLLOW_ruleSwitchClause_in_rule__SwitchStatement__SwitchClauseAssignment_537052);

+            ruleSwitchClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getSwitchStatementAccess().getSwitchClauseSwitchClauseParserRuleCall_5_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__SwitchClauseAssignment_5"

+

+

+    // $ANTLR start "rule__SwitchStatement__DefaultClauseAssignment_6"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18232:1: rule__SwitchStatement__DefaultClauseAssignment_6 : ( ruleSwitchDefaultClause ) ;

+    public final void rule__SwitchStatement__DefaultClauseAssignment_6() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18236:1: ( ( ruleSwitchDefaultClause ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18237:1: ( ruleSwitchDefaultClause )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18237:1: ( ruleSwitchDefaultClause )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18238:1: ruleSwitchDefaultClause

+            {

+             before(grammarAccess.getSwitchStatementAccess().getDefaultClauseSwitchDefaultClauseParserRuleCall_6_0()); 

+            pushFollow(FOLLOW_ruleSwitchDefaultClause_in_rule__SwitchStatement__DefaultClauseAssignment_637083);

+            ruleSwitchDefaultClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getSwitchStatementAccess().getDefaultClauseSwitchDefaultClauseParserRuleCall_6_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchStatement__DefaultClauseAssignment_6"

+

+

+    // $ANTLR start "rule__SwitchClause__SwitchCaseAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18247:1: rule__SwitchClause__SwitchCaseAssignment_0 : ( ruleSwitchCase ) ;

+    public final void rule__SwitchClause__SwitchCaseAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18251:1: ( ( ruleSwitchCase ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18252:1: ( ruleSwitchCase )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18252:1: ( ruleSwitchCase )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18253:1: ruleSwitchCase

+            {

+             before(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleSwitchCase_in_rule__SwitchClause__SwitchCaseAssignment_037114);

+            ruleSwitchCase();

+

+            state._fsp--;

+

+             after(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchClause__SwitchCaseAssignment_0"

+

+

+    // $ANTLR start "rule__SwitchClause__SwitchCaseAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18262:1: rule__SwitchClause__SwitchCaseAssignment_1 : ( ruleSwitchCase ) ;

+    public final void rule__SwitchClause__SwitchCaseAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18266:1: ( ( ruleSwitchCase ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18267:1: ( ruleSwitchCase )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18267:1: ( ruleSwitchCase )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18268:1: ruleSwitchCase

+            {

+             before(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleSwitchCase_in_rule__SwitchClause__SwitchCaseAssignment_137145);

+            ruleSwitchCase();

+

+            state._fsp--;

+

+             after(grammarAccess.getSwitchClauseAccess().getSwitchCaseSwitchCaseParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchClause__SwitchCaseAssignment_1"

+

+

+    // $ANTLR start "rule__SwitchClause__StatementSequenceAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18277:1: rule__SwitchClause__StatementSequenceAssignment_2 : ( ruleNonEmptyStatementSequence ) ;

+    public final void rule__SwitchClause__StatementSequenceAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18281:1: ( ( ruleNonEmptyStatementSequence ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18282:1: ( ruleNonEmptyStatementSequence )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18282:1: ( ruleNonEmptyStatementSequence )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18283:1: ruleNonEmptyStatementSequence

+            {

+             before(grammarAccess.getSwitchClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleNonEmptyStatementSequence_in_rule__SwitchClause__StatementSequenceAssignment_237176);

+            ruleNonEmptyStatementSequence();

+

+            state._fsp--;

+

+             after(grammarAccess.getSwitchClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchClause__StatementSequenceAssignment_2"

+

+

+    // $ANTLR start "rule__SwitchCase__ExpressionAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18292:1: rule__SwitchCase__ExpressionAssignment_1 : ( ruleExpression ) ;

+    public final void rule__SwitchCase__ExpressionAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18296:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18297:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18297:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18298:1: ruleExpression

+            {

+             before(grammarAccess.getSwitchCaseAccess().getExpressionExpressionParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__SwitchCase__ExpressionAssignment_137207);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSwitchCaseAccess().getExpressionExpressionParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchCase__ExpressionAssignment_1"

+

+

+    // $ANTLR start "rule__SwitchDefaultClause__StatementSequenceAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18307:1: rule__SwitchDefaultClause__StatementSequenceAssignment_2 : ( ruleNonEmptyStatementSequence ) ;

+    public final void rule__SwitchDefaultClause__StatementSequenceAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18311:1: ( ( ruleNonEmptyStatementSequence ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18312:1: ( ruleNonEmptyStatementSequence )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18312:1: ( ruleNonEmptyStatementSequence )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18313:1: ruleNonEmptyStatementSequence

+            {

+             before(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleNonEmptyStatementSequence_in_rule__SwitchDefaultClause__StatementSequenceAssignment_237238);

+            ruleNonEmptyStatementSequence();

+

+            state._fsp--;

+

+             after(grammarAccess.getSwitchDefaultClauseAccess().getStatementSequenceNonEmptyStatementSequenceParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SwitchDefaultClause__StatementSequenceAssignment_2"

+

+

+    // $ANTLR start "rule__NonEmptyStatementSequence__StatementAssignment"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18322:1: rule__NonEmptyStatementSequence__StatementAssignment : ( ruleDocumentedStatement ) ;

+    public final void rule__NonEmptyStatementSequence__StatementAssignment() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18326:1: ( ( ruleDocumentedStatement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18327:1: ( ruleDocumentedStatement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18327:1: ( ruleDocumentedStatement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18328:1: ruleDocumentedStatement

+            {

+             before(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementDocumentedStatementParserRuleCall_0()); 

+            pushFollow(FOLLOW_ruleDocumentedStatement_in_rule__NonEmptyStatementSequence__StatementAssignment37269);

+            ruleDocumentedStatement();

+

+            state._fsp--;

+

+             after(grammarAccess.getNonEmptyStatementSequenceAccess().getStatementDocumentedStatementParserRuleCall_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__NonEmptyStatementSequence__StatementAssignment"

+

+

+    // $ANTLR start "rule__WhileStatement__ConditionAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18337:1: rule__WhileStatement__ConditionAssignment_2 : ( ruleExpression ) ;

+    public final void rule__WhileStatement__ConditionAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18341:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18342:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18342:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18343:1: ruleExpression

+            {

+             before(grammarAccess.getWhileStatementAccess().getConditionExpressionParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__WhileStatement__ConditionAssignment_237300);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getWhileStatementAccess().getConditionExpressionParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__WhileStatement__ConditionAssignment_2"

+

+

+    // $ANTLR start "rule__WhileStatement__BlockAssignment_4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18352:1: rule__WhileStatement__BlockAssignment_4 : ( ruleBlock ) ;

+    public final void rule__WhileStatement__BlockAssignment_4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18356:1: ( ( ruleBlock ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18357:1: ( ruleBlock )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18357:1: ( ruleBlock )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18358:1: ruleBlock

+            {

+             before(grammarAccess.getWhileStatementAccess().getBlockBlockParserRuleCall_4_0()); 

+            pushFollow(FOLLOW_ruleBlock_in_rule__WhileStatement__BlockAssignment_437331);

+            ruleBlock();

+

+            state._fsp--;

+

+             after(grammarAccess.getWhileStatementAccess().getBlockBlockParserRuleCall_4_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__WhileStatement__BlockAssignment_4"

+

+

+    // $ANTLR start "rule__DoStatement__BlockAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18367:1: rule__DoStatement__BlockAssignment_1 : ( ruleBlock ) ;

+    public final void rule__DoStatement__BlockAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18371:1: ( ( ruleBlock ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18372:1: ( ruleBlock )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18372:1: ( ruleBlock )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18373:1: ruleBlock

+            {

+             before(grammarAccess.getDoStatementAccess().getBlockBlockParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleBlock_in_rule__DoStatement__BlockAssignment_137362);

+            ruleBlock();

+

+            state._fsp--;

+

+             after(grammarAccess.getDoStatementAccess().getBlockBlockParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__BlockAssignment_1"

+

+

+    // $ANTLR start "rule__DoStatement__ConditionAssignment_4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18382:1: rule__DoStatement__ConditionAssignment_4 : ( ruleExpression ) ;

+    public final void rule__DoStatement__ConditionAssignment_4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18386:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18387:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18387:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18388:1: ruleExpression

+            {

+             before(grammarAccess.getDoStatementAccess().getConditionExpressionParserRuleCall_4_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__DoStatement__ConditionAssignment_437393);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getDoStatementAccess().getConditionExpressionParserRuleCall_4_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__DoStatement__ConditionAssignment_4"

+

+

+    // $ANTLR start "rule__ForStatement__ControlAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18397:1: rule__ForStatement__ControlAssignment_2 : ( ruleForControl ) ;

+    public final void rule__ForStatement__ControlAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18401:1: ( ( ruleForControl ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18402:1: ( ruleForControl )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18402:1: ( ruleForControl )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18403:1: ruleForControl

+            {

+             before(grammarAccess.getForStatementAccess().getControlForControlParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleForControl_in_rule__ForStatement__ControlAssignment_237424);

+            ruleForControl();

+

+            state._fsp--;

+

+             after(grammarAccess.getForStatementAccess().getControlForControlParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForStatement__ControlAssignment_2"

+

+

+    // $ANTLR start "rule__ForStatement__BlockAssignment_4"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18412:1: rule__ForStatement__BlockAssignment_4 : ( ruleBlock ) ;

+    public final void rule__ForStatement__BlockAssignment_4() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18416:1: ( ( ruleBlock ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18417:1: ( ruleBlock )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18417:1: ( ruleBlock )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18418:1: ruleBlock

+            {

+             before(grammarAccess.getForStatementAccess().getBlockBlockParserRuleCall_4_0()); 

+            pushFollow(FOLLOW_ruleBlock_in_rule__ForStatement__BlockAssignment_437455);

+            ruleBlock();

+

+            state._fsp--;

+

+             after(grammarAccess.getForStatementAccess().getBlockBlockParserRuleCall_4_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForStatement__BlockAssignment_4"

+

+

+    // $ANTLR start "rule__ForControl__LoopVariableDefinitionAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18427:1: rule__ForControl__LoopVariableDefinitionAssignment_0 : ( ruleLoopVariableDefinition ) ;

+    public final void rule__ForControl__LoopVariableDefinitionAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18431:1: ( ( ruleLoopVariableDefinition ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18432:1: ( ruleLoopVariableDefinition )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18432:1: ( ruleLoopVariableDefinition )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18433:1: ruleLoopVariableDefinition

+            {

+             before(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleLoopVariableDefinition_in_rule__ForControl__LoopVariableDefinitionAssignment_037486);

+            ruleLoopVariableDefinition();

+

+            state._fsp--;

+

+             after(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForControl__LoopVariableDefinitionAssignment_0"

+

+

+    // $ANTLR start "rule__ForControl__LoopVariableDefinitionAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18442:1: rule__ForControl__LoopVariableDefinitionAssignment_1_1 : ( ruleLoopVariableDefinition ) ;

+    public final void rule__ForControl__LoopVariableDefinitionAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18446:1: ( ( ruleLoopVariableDefinition ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18447:1: ( ruleLoopVariableDefinition )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18447:1: ( ruleLoopVariableDefinition )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18448:1: ruleLoopVariableDefinition

+            {

+             before(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleLoopVariableDefinition_in_rule__ForControl__LoopVariableDefinitionAssignment_1_137517);

+            ruleLoopVariableDefinition();

+

+            state._fsp--;

+

+             after(grammarAccess.getForControlAccess().getLoopVariableDefinitionLoopVariableDefinitionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ForControl__LoopVariableDefinitionAssignment_1_1"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__NameAssignment_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18457:1: rule__LoopVariableDefinition__NameAssignment_0_0 : ( RULE_ID ) ;

+    public final void rule__LoopVariableDefinition__NameAssignment_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18461:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18462:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18462:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18463:1: RULE_ID

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getNameIDTerminalRuleCall_0_0_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__LoopVariableDefinition__NameAssignment_0_037548); 

+             after(grammarAccess.getLoopVariableDefinitionAccess().getNameIDTerminalRuleCall_0_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__NameAssignment_0_0"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Expression1Assignment_0_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18472:1: rule__LoopVariableDefinition__Expression1Assignment_0_2 : ( ruleExpression ) ;

+    public final void rule__LoopVariableDefinition__Expression1Assignment_0_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18476:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18477:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18477:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18478:1: ruleExpression

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getExpression1ExpressionParserRuleCall_0_2_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__LoopVariableDefinition__Expression1Assignment_0_237579);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getLoopVariableDefinitionAccess().getExpression1ExpressionParserRuleCall_0_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Expression1Assignment_0_2"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__Expression2Assignment_0_3_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18487:1: rule__LoopVariableDefinition__Expression2Assignment_0_3_1 : ( ruleExpression ) ;

+    public final void rule__LoopVariableDefinition__Expression2Assignment_0_3_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18491:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18492:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18492:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18493:1: ruleExpression

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getExpression2ExpressionParserRuleCall_0_3_1_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__LoopVariableDefinition__Expression2Assignment_0_3_137610);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getLoopVariableDefinitionAccess().getExpression2ExpressionParserRuleCall_0_3_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__Expression2Assignment_0_3_1"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__TypeAssignment_1_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18502:1: rule__LoopVariableDefinition__TypeAssignment_1_0 : ( ruleQualifiedNameWithBinding ) ;

+    public final void rule__LoopVariableDefinition__TypeAssignment_1_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18506:1: ( ( ruleQualifiedNameWithBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18507:1: ( ruleQualifiedNameWithBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18507:1: ( ruleQualifiedNameWithBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18508:1: ruleQualifiedNameWithBinding

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getTypeQualifiedNameWithBindingParserRuleCall_1_0_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNameWithBinding_in_rule__LoopVariableDefinition__TypeAssignment_1_037641);

+            ruleQualifiedNameWithBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getLoopVariableDefinitionAccess().getTypeQualifiedNameWithBindingParserRuleCall_1_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__TypeAssignment_1_0"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__NameAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18517:1: rule__LoopVariableDefinition__NameAssignment_1_1 : ( RULE_ID ) ;

+    public final void rule__LoopVariableDefinition__NameAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18521:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18522:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18522:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18523:1: RULE_ID

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getNameIDTerminalRuleCall_1_1_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__LoopVariableDefinition__NameAssignment_1_137672); 

+             after(grammarAccess.getLoopVariableDefinitionAccess().getNameIDTerminalRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__NameAssignment_1_1"

+

+

+    // $ANTLR start "rule__LoopVariableDefinition__ExpressionAssignment_1_3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18532:1: rule__LoopVariableDefinition__ExpressionAssignment_1_3 : ( ruleExpression ) ;

+    public final void rule__LoopVariableDefinition__ExpressionAssignment_1_3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18536:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18537:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18537:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18538:1: ruleExpression

+            {

+             before(grammarAccess.getLoopVariableDefinitionAccess().getExpressionExpressionParserRuleCall_1_3_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__LoopVariableDefinition__ExpressionAssignment_1_337703);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getLoopVariableDefinitionAccess().getExpressionExpressionParserRuleCall_1_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__LoopVariableDefinition__ExpressionAssignment_1_3"

+

+

+    // $ANTLR start "rule__ReturnStatement__ExpressionAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18547:1: rule__ReturnStatement__ExpressionAssignment_1 : ( ruleExpression ) ;

+    public final void rule__ReturnStatement__ExpressionAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18551:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18552:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18552:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18553:1: ruleExpression

+            {

+             before(grammarAccess.getReturnStatementAccess().getExpressionExpressionParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__ReturnStatement__ExpressionAssignment_137734);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getReturnStatementAccess().getExpressionExpressionParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ReturnStatement__ExpressionAssignment_1"

+

+

+    // $ANTLR start "rule__AcceptStatement__ClauseAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18562:1: rule__AcceptStatement__ClauseAssignment_0 : ( ruleAcceptClause ) ;

+    public final void rule__AcceptStatement__ClauseAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18566:1: ( ( ruleAcceptClause ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18567:1: ( ruleAcceptClause )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18567:1: ( ruleAcceptClause )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18568:1: ruleAcceptClause

+            {

+             before(grammarAccess.getAcceptStatementAccess().getClauseAcceptClauseParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleAcceptClause_in_rule__AcceptStatement__ClauseAssignment_037765);

+            ruleAcceptClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getAcceptStatementAccess().getClauseAcceptClauseParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptStatement__ClauseAssignment_0"

+

+

+    // $ANTLR start "rule__AcceptStatement__SimpleAcceptAssignment_1_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18577:1: rule__AcceptStatement__SimpleAcceptAssignment_1_0 : ( ruleSimpleAcceptStatementCompletion ) ;

+    public final void rule__AcceptStatement__SimpleAcceptAssignment_1_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18581:1: ( ( ruleSimpleAcceptStatementCompletion ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18582:1: ( ruleSimpleAcceptStatementCompletion )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18582:1: ( ruleSimpleAcceptStatementCompletion )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18583:1: ruleSimpleAcceptStatementCompletion

+            {

+             before(grammarAccess.getAcceptStatementAccess().getSimpleAcceptSimpleAcceptStatementCompletionParserRuleCall_1_0_0()); 

+            pushFollow(FOLLOW_ruleSimpleAcceptStatementCompletion_in_rule__AcceptStatement__SimpleAcceptAssignment_1_037796);

+            ruleSimpleAcceptStatementCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getAcceptStatementAccess().getSimpleAcceptSimpleAcceptStatementCompletionParserRuleCall_1_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptStatement__SimpleAcceptAssignment_1_0"

+

+

+    // $ANTLR start "rule__AcceptStatement__CompoundAcceptAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18592:1: rule__AcceptStatement__CompoundAcceptAssignment_1_1 : ( ruleCompoundAcceptStatementCompletion ) ;

+    public final void rule__AcceptStatement__CompoundAcceptAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18596:1: ( ( ruleCompoundAcceptStatementCompletion ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18597:1: ( ruleCompoundAcceptStatementCompletion )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18597:1: ( ruleCompoundAcceptStatementCompletion )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18598:1: ruleCompoundAcceptStatementCompletion

+            {

+             before(grammarAccess.getAcceptStatementAccess().getCompoundAcceptCompoundAcceptStatementCompletionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleCompoundAcceptStatementCompletion_in_rule__AcceptStatement__CompoundAcceptAssignment_1_137827);

+            ruleCompoundAcceptStatementCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getAcceptStatementAccess().getCompoundAcceptCompoundAcceptStatementCompletionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptStatement__CompoundAcceptAssignment_1_1"

+

+

+    // $ANTLR start "rule__CompoundAcceptStatementCompletion__BlockAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18607:1: rule__CompoundAcceptStatementCompletion__BlockAssignment_0 : ( ruleBlock ) ;

+    public final void rule__CompoundAcceptStatementCompletion__BlockAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18611:1: ( ( ruleBlock ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18612:1: ( ruleBlock )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18612:1: ( ruleBlock )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18613:1: ruleBlock

+            {

+             before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockBlockParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleBlock_in_rule__CompoundAcceptStatementCompletion__BlockAssignment_037858);

+            ruleBlock();

+

+            state._fsp--;

+

+             after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getBlockBlockParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CompoundAcceptStatementCompletion__BlockAssignment_0"

+

+

+    // $ANTLR start "rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18622:1: rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1 : ( ruleAcceptBlock ) ;

+    public final void rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18626:1: ( ( ruleAcceptBlock ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18627:1: ( ruleAcceptBlock )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18627:1: ( ruleAcceptBlock )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18628:1: ruleAcceptBlock

+            {

+             before(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAcceptBlockParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleAcceptBlock_in_rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_137889);

+            ruleAcceptBlock();

+

+            state._fsp--;

+

+             after(grammarAccess.getCompoundAcceptStatementCompletionAccess().getAcceptBlockAcceptBlockParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1"

+

+

+    // $ANTLR start "rule__AcceptBlock__ClauseAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18637:1: rule__AcceptBlock__ClauseAssignment_0 : ( ruleAcceptClause ) ;

+    public final void rule__AcceptBlock__ClauseAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18641:1: ( ( ruleAcceptClause ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18642:1: ( ruleAcceptClause )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18642:1: ( ruleAcceptClause )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18643:1: ruleAcceptClause

+            {

+             before(grammarAccess.getAcceptBlockAccess().getClauseAcceptClauseParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleAcceptClause_in_rule__AcceptBlock__ClauseAssignment_037920);

+            ruleAcceptClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getAcceptBlockAccess().getClauseAcceptClauseParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptBlock__ClauseAssignment_0"

+

+

+    // $ANTLR start "rule__AcceptBlock__BlockAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18652:1: rule__AcceptBlock__BlockAssignment_1 : ( ruleBlock ) ;

+    public final void rule__AcceptBlock__BlockAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18656:1: ( ( ruleBlock ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18657:1: ( ruleBlock )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18657:1: ( ruleBlock )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18658:1: ruleBlock

+            {

+             before(grammarAccess.getAcceptBlockAccess().getBlockBlockParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleBlock_in_rule__AcceptBlock__BlockAssignment_137951);

+            ruleBlock();

+

+            state._fsp--;

+

+             after(grammarAccess.getAcceptBlockAccess().getBlockBlockParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptBlock__BlockAssignment_1"

+

+

+    // $ANTLR start "rule__AcceptClause__NameAssignment_2_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18667:1: rule__AcceptClause__NameAssignment_2_0 : ( RULE_ID ) ;

+    public final void rule__AcceptClause__NameAssignment_2_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18671:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18672:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18672:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18673:1: RULE_ID

+            {

+             before(grammarAccess.getAcceptClauseAccess().getNameIDTerminalRuleCall_2_0_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__AcceptClause__NameAssignment_2_037982); 

+             after(grammarAccess.getAcceptClauseAccess().getNameIDTerminalRuleCall_2_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__NameAssignment_2_0"

+

+

+    // $ANTLR start "rule__AcceptClause__QualifiedNameListAssignment_3"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18682:1: rule__AcceptClause__QualifiedNameListAssignment_3 : ( ruleQualifiedNameList ) ;

+    public final void rule__AcceptClause__QualifiedNameListAssignment_3() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18686:1: ( ( ruleQualifiedNameList ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18687:1: ( ruleQualifiedNameList )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18687:1: ( ruleQualifiedNameList )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18688:1: ruleQualifiedNameList

+            {

+             before(grammarAccess.getAcceptClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_3_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNameList_in_rule__AcceptClause__QualifiedNameListAssignment_338013);

+            ruleQualifiedNameList();

+

+            state._fsp--;

+

+             after(grammarAccess.getAcceptClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_3_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AcceptClause__QualifiedNameListAssignment_3"

+

+

+    // $ANTLR start "rule__ClassifyStatement__ExpressionAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18697:1: rule__ClassifyStatement__ExpressionAssignment_1 : ( ruleExpression ) ;

+    public final void rule__ClassifyStatement__ExpressionAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18701:1: ( ( ruleExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18702:1: ( ruleExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18702:1: ( ruleExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18703:1: ruleExpression

+            {

+             before(grammarAccess.getClassifyStatementAccess().getExpressionExpressionParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleExpression_in_rule__ClassifyStatement__ExpressionAssignment_138044);

+            ruleExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassifyStatementAccess().getExpressionExpressionParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassifyStatement__ExpressionAssignment_1"

+

+

+    // $ANTLR start "rule__ClassifyStatement__ClauseAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18712:1: rule__ClassifyStatement__ClauseAssignment_2 : ( ruleClassificationClause ) ;

+    public final void rule__ClassifyStatement__ClauseAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18716:1: ( ( ruleClassificationClause ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18717:1: ( ruleClassificationClause )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18717:1: ( ruleClassificationClause )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18718:1: ruleClassificationClause

+            {

+             before(grammarAccess.getClassifyStatementAccess().getClauseClassificationClauseParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleClassificationClause_in_rule__ClassifyStatement__ClauseAssignment_238075);

+            ruleClassificationClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassifyStatementAccess().getClauseClassificationClauseParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassifyStatement__ClauseAssignment_2"

+

+

+    // $ANTLR start "rule__ClassificationClause__ClassifyFromClauseAssignment_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18727:1: rule__ClassificationClause__ClassifyFromClauseAssignment_0_0 : ( ruleClassificationFromClause ) ;

+    public final void rule__ClassificationClause__ClassifyFromClauseAssignment_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18731:1: ( ( ruleClassificationFromClause ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18732:1: ( ruleClassificationFromClause )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18732:1: ( ruleClassificationFromClause )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18733:1: ruleClassificationFromClause

+            {

+             before(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseClassificationFromClauseParserRuleCall_0_0_0()); 

+            pushFollow(FOLLOW_ruleClassificationFromClause_in_rule__ClassificationClause__ClassifyFromClauseAssignment_0_038106);

+            ruleClassificationFromClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassificationClauseAccess().getClassifyFromClauseClassificationFromClauseParserRuleCall_0_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationClause__ClassifyFromClauseAssignment_0_0"

+

+

+    // $ANTLR start "rule__ClassificationClause__ClassifyToClauseAssignment_0_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18742:1: rule__ClassificationClause__ClassifyToClauseAssignment_0_1 : ( ruleClassificationToClause ) ;

+    public final void rule__ClassificationClause__ClassifyToClauseAssignment_0_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18746:1: ( ( ruleClassificationToClause ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18747:1: ( ruleClassificationToClause )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18747:1: ( ruleClassificationToClause )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18748:1: ruleClassificationToClause

+            {

+             before(grammarAccess.getClassificationClauseAccess().getClassifyToClauseClassificationToClauseParserRuleCall_0_1_0()); 

+            pushFollow(FOLLOW_ruleClassificationToClause_in_rule__ClassificationClause__ClassifyToClauseAssignment_0_138137);

+            ruleClassificationToClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassificationClauseAccess().getClassifyToClauseClassificationToClauseParserRuleCall_0_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationClause__ClassifyToClauseAssignment_0_1"

+

+

+    // $ANTLR start "rule__ClassificationClause__ReclassyAllClauseAssignment_1_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18757:1: rule__ClassificationClause__ReclassyAllClauseAssignment_1_0 : ( ruleReclassifyAllClause ) ;

+    public final void rule__ClassificationClause__ReclassyAllClauseAssignment_1_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18761:1: ( ( ruleReclassifyAllClause ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18762:1: ( ruleReclassifyAllClause )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18762:1: ( ruleReclassifyAllClause )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18763:1: ruleReclassifyAllClause

+            {

+             before(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseReclassifyAllClauseParserRuleCall_1_0_0()); 

+            pushFollow(FOLLOW_ruleReclassifyAllClause_in_rule__ClassificationClause__ReclassyAllClauseAssignment_1_038168);

+            ruleReclassifyAllClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassificationClauseAccess().getReclassyAllClauseReclassifyAllClauseParserRuleCall_1_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationClause__ReclassyAllClauseAssignment_1_0"

+

+

+    // $ANTLR start "rule__ClassificationClause__ClassifyToClauseAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18772:1: rule__ClassificationClause__ClassifyToClauseAssignment_1_1 : ( ruleClassificationToClause ) ;

+    public final void rule__ClassificationClause__ClassifyToClauseAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18776:1: ( ( ruleClassificationToClause ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18777:1: ( ruleClassificationToClause )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18777:1: ( ruleClassificationToClause )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18778:1: ruleClassificationToClause

+            {

+             before(grammarAccess.getClassificationClauseAccess().getClassifyToClauseClassificationToClauseParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleClassificationToClause_in_rule__ClassificationClause__ClassifyToClauseAssignment_1_138199);

+            ruleClassificationToClause();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassificationClauseAccess().getClassifyToClauseClassificationToClauseParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationClause__ClassifyToClauseAssignment_1_1"

+

+

+    // $ANTLR start "rule__ClassificationFromClause__QualifiedNameListAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18787:1: rule__ClassificationFromClause__QualifiedNameListAssignment_1 : ( ruleQualifiedNameList ) ;

+    public final void rule__ClassificationFromClause__QualifiedNameListAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18791:1: ( ( ruleQualifiedNameList ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18792:1: ( ruleQualifiedNameList )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18792:1: ( ruleQualifiedNameList )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18793:1: ruleQualifiedNameList

+            {

+             before(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNameList_in_rule__ClassificationFromClause__QualifiedNameListAssignment_138230);

+            ruleQualifiedNameList();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassificationFromClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationFromClause__QualifiedNameListAssignment_1"

+

+

+    // $ANTLR start "rule__ClassificationToClause__QualifiedNameListAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18802:1: rule__ClassificationToClause__QualifiedNameListAssignment_1 : ( ruleQualifiedNameList ) ;

+    public final void rule__ClassificationToClause__QualifiedNameListAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18806:1: ( ( ruleQualifiedNameList ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18807:1: ( ruleQualifiedNameList )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18807:1: ( ruleQualifiedNameList )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18808:1: ruleQualifiedNameList

+            {

+             before(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNameList_in_rule__ClassificationToClause__QualifiedNameListAssignment_138261);

+            ruleQualifiedNameList();

+

+            state._fsp--;

+

+             after(grammarAccess.getClassificationToClauseAccess().getQualifiedNameListQualifiedNameListParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ClassificationToClause__QualifiedNameListAssignment_1"

+

+

+    // $ANTLR start "rule__QualifiedNameList__QualifiedNameAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18817:1: rule__QualifiedNameList__QualifiedNameAssignment_0 : ( ruleQualifiedNameWithBinding ) ;

+    public final void rule__QualifiedNameList__QualifiedNameAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18821:1: ( ( ruleQualifiedNameWithBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18822:1: ( ruleQualifiedNameWithBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18822:1: ( ruleQualifiedNameWithBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18823:1: ruleQualifiedNameWithBinding

+            {

+             before(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameWithBindingParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNameWithBinding_in_rule__QualifiedNameList__QualifiedNameAssignment_038292);

+            ruleQualifiedNameWithBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameWithBindingParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameList__QualifiedNameAssignment_0"

+

+

+    // $ANTLR start "rule__QualifiedNameList__QualifiedNameAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18832:1: rule__QualifiedNameList__QualifiedNameAssignment_1_1 : ( ruleQualifiedNameWithBinding ) ;

+    public final void rule__QualifiedNameList__QualifiedNameAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18836:1: ( ( ruleQualifiedNameWithBinding ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18837:1: ( ruleQualifiedNameWithBinding )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18837:1: ( ruleQualifiedNameWithBinding )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18838:1: ruleQualifiedNameWithBinding

+            {

+             before(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameWithBindingParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleQualifiedNameWithBinding_in_rule__QualifiedNameList__QualifiedNameAssignment_1_138323);

+            ruleQualifiedNameWithBinding();

+

+            state._fsp--;

+

+             after(grammarAccess.getQualifiedNameListAccess().getQualifiedNameQualifiedNameWithBindingParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__QualifiedNameList__QualifiedNameAssignment_1_1"

+

+

+    // $ANTLR start "rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18847:1: rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0 : ( ruleNameExpression ) ;

+    public final void rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18851:1: ( ( ruleNameExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18852:1: ( ruleNameExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18852:1: ( ruleNameExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18853:1: ruleNameExpression

+            {

+             before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartNameExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleNameExpression_in_rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_038354);

+            ruleNameExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getTypePart_OR_assignedPart_OR_invocationPartNameExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0"

+

+

+    // $ANTLR start "rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18862:1: rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0 : ( ruleVariableDeclarationCompletion ) ;

+    public final void rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18866:1: ( ( ruleVariableDeclarationCompletion ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18867:1: ( ruleVariableDeclarationCompletion )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18867:1: ( ruleVariableDeclarationCompletion )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18868:1: ruleVariableDeclarationCompletion

+            {

+             before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionVariableDeclarationCompletionParserRuleCall_1_0_0()); 

+            pushFollow(FOLLOW_ruleVariableDeclarationCompletion_in_rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_038385);

+            ruleVariableDeclarationCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getVariableDeclarationCompletionVariableDeclarationCompletionParserRuleCall_1_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0"

+

+

+    // $ANTLR start "rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18877:1: rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1 : ( ruleAssignmentCompletion ) ;

+    public final void rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18881:1: ( ( ruleAssignmentCompletion ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18882:1: ( ruleAssignmentCompletion )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18882:1: ( ruleAssignmentCompletion )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18883:1: ruleAssignmentCompletion

+            {

+             before(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignmentCompletionParserRuleCall_1_1_0()); 

+            pushFollow(FOLLOW_ruleAssignmentCompletion_in_rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_138416);

+            ruleAssignmentCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getInvocationOrAssignementOrDeclarationStatementAccess().getAssignmentCompletionAssignmentCompletionParserRuleCall_1_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1"

+

+

+    // $ANTLR start "rule__SuperInvocationStatement___superAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18892:1: rule__SuperInvocationStatement___superAssignment_0 : ( ruleSuperInvocationExpression ) ;

+    public final void rule__SuperInvocationStatement___superAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18896:1: ( ( ruleSuperInvocationExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18897:1: ( ruleSuperInvocationExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18897:1: ( ruleSuperInvocationExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18898:1: ruleSuperInvocationExpression

+            {

+             before(grammarAccess.getSuperInvocationStatementAccess().get_superSuperInvocationExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleSuperInvocationExpression_in_rule__SuperInvocationStatement___superAssignment_038447);

+            ruleSuperInvocationExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getSuperInvocationStatementAccess().get_superSuperInvocationExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__SuperInvocationStatement___superAssignment_0"

+

+

+    // $ANTLR start "rule__ThisInvocationStatement___thisAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18907:1: rule__ThisInvocationStatement___thisAssignment_0 : ( ruleThisExpression ) ;

+    public final void rule__ThisInvocationStatement___thisAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18911:1: ( ( ruleThisExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18912:1: ( ruleThisExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18912:1: ( ruleThisExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18913:1: ruleThisExpression

+            {

+             before(grammarAccess.getThisInvocationStatementAccess().get_thisThisExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleThisExpression_in_rule__ThisInvocationStatement___thisAssignment_038478);

+            ruleThisExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getThisInvocationStatementAccess().get_thisThisExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisInvocationStatement___thisAssignment_0"

+

+

+    // $ANTLR start "rule__ThisInvocationStatement__AssignmentCompletionAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18922:1: rule__ThisInvocationStatement__AssignmentCompletionAssignment_1 : ( ruleAssignmentCompletion ) ;

+    public final void rule__ThisInvocationStatement__AssignmentCompletionAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18926:1: ( ( ruleAssignmentCompletion ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18927:1: ( ruleAssignmentCompletion )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18927:1: ( ruleAssignmentCompletion )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18928:1: ruleAssignmentCompletion

+            {

+             before(grammarAccess.getThisInvocationStatementAccess().getAssignmentCompletionAssignmentCompletionParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleAssignmentCompletion_in_rule__ThisInvocationStatement__AssignmentCompletionAssignment_138509);

+            ruleAssignmentCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getThisInvocationStatementAccess().getAssignmentCompletionAssignmentCompletionParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__ThisInvocationStatement__AssignmentCompletionAssignment_1"

+

+

+    // $ANTLR start "rule__InstanceCreationInvocationStatement___newAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18937:1: rule__InstanceCreationInvocationStatement___newAssignment_0 : ( ruleInstanceCreationExpression ) ;

+    public final void rule__InstanceCreationInvocationStatement___newAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18941:1: ( ( ruleInstanceCreationExpression ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18942:1: ( ruleInstanceCreationExpression )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18942:1: ( ruleInstanceCreationExpression )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18943:1: ruleInstanceCreationExpression

+            {

+             before(grammarAccess.getInstanceCreationInvocationStatementAccess().get_newInstanceCreationExpressionParserRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleInstanceCreationExpression_in_rule__InstanceCreationInvocationStatement___newAssignment_038540);

+            ruleInstanceCreationExpression();

+

+            state._fsp--;

+

+             after(grammarAccess.getInstanceCreationInvocationStatementAccess().get_newInstanceCreationExpressionParserRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__InstanceCreationInvocationStatement___newAssignment_0"

+

+

+    // $ANTLR start "rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18952:1: rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0 : ( ( '[' ) ) ;

+    public final void rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18956:1: ( ( ( '[' ) ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18957:1: ( ( '[' ) )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18957:1: ( ( '[' ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18958:1: ( '[' )

+            {

+             before(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); 

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18959:1: ( '[' )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18960:1: '['

+            {

+             before(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); 

+            match(input,78,FOLLOW_78_in_rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_038576); 

+             after(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); 

+

+            }

+

+             after(grammarAccess.getVariableDeclarationCompletionAccess().getMultiplicityIndicatorLeftSquareBracketKeyword_0_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0"

+

+

+    // $ANTLR start "rule__VariableDeclarationCompletion__VariableNameAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18975:1: rule__VariableDeclarationCompletion__VariableNameAssignment_1 : ( RULE_ID ) ;

+    public final void rule__VariableDeclarationCompletion__VariableNameAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18979:1: ( ( RULE_ID ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18980:1: ( RULE_ID )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18980:1: ( RULE_ID )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18981:1: RULE_ID

+            {

+             before(grammarAccess.getVariableDeclarationCompletionAccess().getVariableNameIDTerminalRuleCall_1_0()); 

+            match(input,RULE_ID,FOLLOW_RULE_ID_in_rule__VariableDeclarationCompletion__VariableNameAssignment_138615); 

+             after(grammarAccess.getVariableDeclarationCompletionAccess().getVariableNameIDTerminalRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__VariableDeclarationCompletion__VariableNameAssignment_1"

+

+

+    // $ANTLR start "rule__VariableDeclarationCompletion__InitValueAssignment_2"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18990:1: rule__VariableDeclarationCompletion__InitValueAssignment_2 : ( ruleAssignmentCompletion ) ;

+    public final void rule__VariableDeclarationCompletion__InitValueAssignment_2() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18994:1: ( ( ruleAssignmentCompletion ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18995:1: ( ruleAssignmentCompletion )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18995:1: ( ruleAssignmentCompletion )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:18996:1: ruleAssignmentCompletion

+            {

+             before(grammarAccess.getVariableDeclarationCompletionAccess().getInitValueAssignmentCompletionParserRuleCall_2_0()); 

+            pushFollow(FOLLOW_ruleAssignmentCompletion_in_rule__VariableDeclarationCompletion__InitValueAssignment_238646);

+            ruleAssignmentCompletion();

+

+            state._fsp--;

+

+             after(grammarAccess.getVariableDeclarationCompletionAccess().getInitValueAssignmentCompletionParserRuleCall_2_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__VariableDeclarationCompletion__InitValueAssignment_2"

+

+

+    // $ANTLR start "rule__AssignmentCompletion__OpAssignment_0"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19005:1: rule__AssignmentCompletion__OpAssignment_0 : ( ruleAssignmentOperator ) ;

+    public final void rule__AssignmentCompletion__OpAssignment_0() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19009:1: ( ( ruleAssignmentOperator ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19010:1: ( ruleAssignmentOperator )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19010:1: ( ruleAssignmentOperator )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19011:1: ruleAssignmentOperator

+            {

+             before(grammarAccess.getAssignmentCompletionAccess().getOpAssignmentOperatorEnumRuleCall_0_0()); 

+            pushFollow(FOLLOW_ruleAssignmentOperator_in_rule__AssignmentCompletion__OpAssignment_038677);

+            ruleAssignmentOperator();

+

+            state._fsp--;

+

+             after(grammarAccess.getAssignmentCompletionAccess().getOpAssignmentOperatorEnumRuleCall_0_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AssignmentCompletion__OpAssignment_0"

+

+

+    // $ANTLR start "rule__AssignmentCompletion__RightHandSideAssignment_1"

+    // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19020:1: rule__AssignmentCompletion__RightHandSideAssignment_1 : ( ruleSequenceElement ) ;

+    public final void rule__AssignmentCompletion__RightHandSideAssignment_1() throws RecognitionException {

+

+        		int stackSize = keepStackSize();

+            

+        try {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19024:1: ( ( ruleSequenceElement ) )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19025:1: ( ruleSequenceElement )

+            {

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19025:1: ( ruleSequenceElement )

+            // ../org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/contentassist/antlr/internal/InternalAlf.g:19026:1: ruleSequenceElement

+            {

+             before(grammarAccess.getAssignmentCompletionAccess().getRightHandSideSequenceElementParserRuleCall_1_0()); 

+            pushFollow(FOLLOW_ruleSequenceElement_in_rule__AssignmentCompletion__RightHandSideAssignment_138708);

+            ruleSequenceElement();

+

+            state._fsp--;

+

+             after(grammarAccess.getAssignmentCompletionAccess().getRightHandSideSequenceElementParserRuleCall_1_0()); 

+

+            }

+

+

+            }

+

+        }

+        catch (RecognitionException re) {

+            reportError(re);

+            recover(input,re);

+        }

+        finally {

+

+            	restoreStackSize(stackSize);

+

+        }

+        return ;

+    }

+    // $ANTLR end "rule__AssignmentCompletion__RightHandSideAssignment_1"

+

+    // Delegated rules

+

+

+    protected DFA17 dfa17 = new DFA17(this);

+    static final String DFA17_eotS =

+        "\13\uffff";

+    static final String DFA17_eofS =

+        "\3\uffff\1\12\7\uffff";

+    static final String DFA17_minS =

+        "\1\115\3\10\7\uffff";

+    static final String DFA17_maxS =

+        "\1\120\1\132\1\122\1\160\7\uffff";

+    static final String DFA17_acceptS =

+        "\4\uffff\1\7\1\3\1\6\1\5\1\4\1\1\1\2";

+    static final String DFA17_specialS =

+        "\13\uffff}>";

+    static final String[] DFA17_transitionS = {

+            "\1\1\2\uffff\1\2",

+            "\1\3\32\uffff\3\5\64\uffff\1\4",

+            "\1\10\35\uffff\7\6\44\uffff\1\7\1\6",

+            "\1\12\5\uffff\20\12\23\uffff\20\12\1\uffff\1\12\1\uffff\1"+

+            "\11\14\12\7\uffff\2\12\5\uffff\1\12\17\uffff\2\12",

+            "",

+            "",

+            "",

+            "",

+            "",

+            "",

+            ""

+    };

+

+    static final short[] DFA17_eot = DFA.unpackEncodedString(DFA17_eotS);

+    static final short[] DFA17_eof = DFA.unpackEncodedString(DFA17_eofS);

+    static final char[] DFA17_min = DFA.unpackEncodedStringToUnsignedChars(DFA17_minS);

+    static final char[] DFA17_max = DFA.unpackEncodedStringToUnsignedChars(DFA17_maxS);

+    static final short[] DFA17_accept = DFA.unpackEncodedString(DFA17_acceptS);

+    static final short[] DFA17_special = DFA.unpackEncodedString(DFA17_specialS);

+    static final short[][] DFA17_transition;

+

+    static {

+        int numStates = DFA17_transitionS.length;

+        DFA17_transition = new short[numStates][];

+        for (int i=0; i<numStates; i++) {

+            DFA17_transition[i] = DFA.unpackEncodedString(DFA17_transitionS[i]);

+        }

+    }

+

+    class DFA17 extends DFA {

+

+        public DFA17(BaseRecognizer recognizer) {

+            this.recognizer = recognizer;

+            this.decisionNumber = 17;

+            this.eot = DFA17_eot;

+            this.eof = DFA17_eof;

+            this.min = DFA17_min;

+            this.max = DFA17_max;

+            this.accept = DFA17_accept;

+            this.special = DFA17_special;

+            this.transition = DFA17_transition;

+        }

+        public String getDescription() {

+            return "3460:1: rule__SuffixExpression__Alternatives : ( ( ruleOperationCallExpression ) | ( rulePropertyCallExpression ) | ( ruleLinkOperationExpression ) | ( ruleSequenceOperationExpression ) | ( ruleSequenceReductionExpression ) | ( ruleSequenceExpansionExpression ) | ( ruleClassExtentExpression ) );";

+        }

+    }

+ 

+

+    public static final BitSet FOLLOW_ruleTest_in_entryRuleTest61 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleTest68 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group__0_in_ruleTest94 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLITERAL_in_entryRuleLITERAL121 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleLITERAL128 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LITERAL__Alternatives_in_ruleLITERAL154 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBOOLEAN_LITERAL_in_entryRuleBOOLEAN_LITERAL181 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleBOOLEAN_LITERAL188 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__BOOLEAN_LITERAL__ValueAssignment_in_ruleBOOLEAN_LITERAL214 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNUMBER_LITERAL_in_entryRuleNUMBER_LITERAL241 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleNUMBER_LITERAL248 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NUMBER_LITERAL__Alternatives_in_ruleNUMBER_LITERAL274 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleINTEGER_LITERAL_in_entryRuleINTEGER_LITERAL301 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleINTEGER_LITERAL308 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__INTEGER_LITERAL__ValueAssignment_in_ruleINTEGER_LITERAL334 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleUNLIMITED_LITERAL_in_entryRuleUNLIMITED_LITERAL361 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleUNLIMITED_LITERAL368 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__UNLIMITED_LITERAL__ValueAssignment_in_ruleUNLIMITED_LITERAL394 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSTRING_LITERAL_in_entryRuleSTRING_LITERAL421 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSTRING_LITERAL428 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__STRING_LITERAL__ValueAssignment_in_ruleSTRING_LITERAL454 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNameExpression_in_entryRuleNameExpression481 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleNameExpression488 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group__0_in_ruleNameExpression514 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNamePath_in_entryRuleQualifiedNamePath541 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleQualifiedNamePath548 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNamePath__Group__0_in_ruleQualifiedNamePath576 = new BitSet(new long[]{0x0000000000000102L});

+    public static final BitSet FOLLOW_rule__QualifiedNamePath__Group__0_in_ruleQualifiedNamePath588 = new BitSet(new long[]{0x0000000000000102L});

+    public static final BitSet FOLLOW_ruleUnqualifiedName_in_entryRuleUnqualifiedName618 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleUnqualifiedName625 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__UnqualifiedName__Group__0_in_ruleUnqualifiedName651 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleTemplateBinding_in_entryRuleTemplateBinding678 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleTemplateBinding685 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__Group__0_in_ruleTemplateBinding711 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNamedTemplateBinding_in_entryRuleNamedTemplateBinding738 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleNamedTemplateBinding745 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NamedTemplateBinding__Group__0_in_ruleNamedTemplateBinding771 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameWithBinding_in_entryRuleQualifiedNameWithBinding798 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleQualifiedNameWithBinding805 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameWithBinding__Group__0_in_ruleQualifiedNameWithBinding831 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleTuple_in_entryRuleTuple858 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleTuple865 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Tuple__Group__0_in_ruleTuple891 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleTupleElement_in_entryRuleTupleElement918 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleTupleElement925 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__TupleElement__ArgumentAssignment_in_ruleTupleElement951 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_entryRuleExpression978 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleExpression985 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleConditionalTestExpression_in_ruleExpression1011 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleConditionalTestExpression_in_entryRuleConditionalTestExpression1037 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleConditionalTestExpression1044 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__Group__0_in_ruleConditionalTestExpression1070 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleConditionalOrExpression_in_entryRuleConditionalOrExpression1097 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleConditionalOrExpression1104 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalOrExpression__Group__0_in_ruleConditionalOrExpression1130 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleConditionalAndExpression_in_entryRuleConditionalAndExpression1157 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleConditionalAndExpression1164 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalAndExpression__Group__0_in_ruleConditionalAndExpression1190 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInclusiveOrExpression_in_entryRuleInclusiveOrExpression1217 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleInclusiveOrExpression1224 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InclusiveOrExpression__Group__0_in_ruleInclusiveOrExpression1250 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExclusiveOrExpression_in_entryRuleExclusiveOrExpression1277 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleExclusiveOrExpression1284 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ExclusiveOrExpression__Group__0_in_ruleExclusiveOrExpression1310 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAndExpression_in_entryRuleAndExpression1337 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleAndExpression1344 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AndExpression__Group__0_in_ruleAndExpression1370 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleEqualityExpression_in_entryRuleEqualityExpression1397 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleEqualityExpression1404 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__EqualityExpression__Group__0_in_ruleEqualityExpression1430 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassificationExpression_in_entryRuleClassificationExpression1457 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleClassificationExpression1464 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationExpression__Group__0_in_ruleClassificationExpression1490 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleRelationalExpression_in_entryRuleRelationalExpression1517 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleRelationalExpression1524 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__RelationalExpression__Group__0_in_ruleRelationalExpression1550 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleShiftExpression_in_entryRuleShiftExpression1577 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleShiftExpression1584 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ShiftExpression__Group__0_in_ruleShiftExpression1610 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAdditiveExpression_in_entryRuleAdditiveExpression1637 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleAdditiveExpression1644 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AdditiveExpression__Group__0_in_ruleAdditiveExpression1670 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleMultiplicativeExpression_in_entryRuleMultiplicativeExpression1697 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleMultiplicativeExpression1704 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__MultiplicativeExpression__Group__0_in_ruleMultiplicativeExpression1730 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleUnaryExpression_in_entryRuleUnaryExpression1757 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleUnaryExpression1764 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__UnaryExpression__Group__0_in_ruleUnaryExpression1790 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rulePrimaryExpression_in_entryRulePrimaryExpression1817 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRulePrimaryExpression1824 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PrimaryExpression__PrefixAssignment_in_rulePrimaryExpression1850 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuffixExpression_in_entryRuleSuffixExpression1877 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSuffixExpression1884 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuffixExpression__Alternatives_in_ruleSuffixExpression1910 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleOperationCallExpression_in_entryRuleOperationCallExpression1937 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleOperationCallExpression1944 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__OperationCallExpression__Group__0_in_ruleOperationCallExpression1970 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rulePropertyCallExpression_in_entryRulePropertyCallExpression1997 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRulePropertyCallExpression2004 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group__0_in_rulePropertyCallExpression2030 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLinkOperationExpression_in_entryRuleLinkOperationExpression2057 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleLinkOperationExpression2064 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationExpression__Group__0_in_ruleLinkOperationExpression2090 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLinkOperationTuple_in_entryRuleLinkOperationTuple2117 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleLinkOperationTuple2124 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__Group__0_in_ruleLinkOperationTuple2150 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLinkOperationTupleElement_in_entryRuleLinkOperationTupleElement2177 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleLinkOperationTupleElement2184 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group__0_in_ruleLinkOperationTupleElement2210 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceOperationExpression_in_entryRuleSequenceOperationExpression2237 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSequenceOperationExpression2244 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceOperationExpression__Group__0_in_ruleSequenceOperationExpression2270 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceReductionExpression_in_entryRuleSequenceReductionExpression2297 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSequenceReductionExpression2304 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceReductionExpression__Group__0_in_ruleSequenceReductionExpression2330 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceExpansionExpression_in_entryRuleSequenceExpansionExpression2357 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSequenceExpansionExpression2364 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceExpansionExpression__Alternatives_in_ruleSequenceExpansionExpression2390 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSelectOrRejectOperation_in_entryRuleSelectOrRejectOperation2417 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSelectOrRejectOperation2424 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__0_in_ruleSelectOrRejectOperation2450 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleCollectOrIterateOperation_in_entryRuleCollectOrIterateOperation2477 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleCollectOrIterateOperation2484 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__0_in_ruleCollectOrIterateOperation2510 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleForAllOrExistsOrOneOperation_in_entryRuleForAllOrExistsOrOneOperation2537 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleForAllOrExistsOrOneOperation2544 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__0_in_ruleForAllOrExistsOrOneOperation2570 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleIsUniqueOperation_in_entryRuleIsUniqueOperation2597 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleIsUniqueOperation2604 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__0_in_ruleIsUniqueOperation2630 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleValueSpecification_in_entryRuleValueSpecification2657 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleValueSpecification2664 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ValueSpecification__Alternatives_in_ruleValueSpecification2690 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNonLiteralValueSpecification_in_entryRuleNonLiteralValueSpecification2717 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleNonLiteralValueSpecification2724 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NonLiteralValueSpecification__Alternatives_in_ruleNonLiteralValueSpecification2750 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleParenthesizedExpression_in_entryRuleParenthesizedExpression2777 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleParenthesizedExpression2784 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ParenthesizedExpression__Group__0_in_ruleParenthesizedExpression2810 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNullExpression_in_entryRuleNullExpression2837 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleNullExpression2844 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NullExpression__Group__0_in_ruleNullExpression2870 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleThisExpression_in_entryRuleThisExpression2897 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleThisExpression2904 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ThisExpression__Group__0_in_ruleThisExpression2930 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuperInvocationExpression_in_entryRuleSuperInvocationExpression2957 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSuperInvocationExpression2964 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__Group__0_in_ruleSuperInvocationExpression2990 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInstanceCreationExpression_in_entryRuleInstanceCreationExpression3017 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleInstanceCreationExpression3024 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationExpression__Group__0_in_ruleInstanceCreationExpression3050 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInstanceCreationTuple_in_entryRuleInstanceCreationTuple3077 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleInstanceCreationTuple3084 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group__0_in_ruleInstanceCreationTuple3110 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInstanceCreationTupleElement_in_entryRuleInstanceCreationTupleElement3137 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleInstanceCreationTupleElement3144 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTupleElement__Group__0_in_ruleInstanceCreationTupleElement3170 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceConstructionOrAccessCompletion_in_entryRuleSequenceConstructionOrAccessCompletion3197 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSequenceConstructionOrAccessCompletion3204 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionOrAccessCompletion__Alternatives_in_ruleSequenceConstructionOrAccessCompletion3230 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAccessCompletion_in_entryRuleAccessCompletion3257 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleAccessCompletion3264 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AccessCompletion__Group__0_in_ruleAccessCompletion3290 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rulePartialSequenceConstructionCompletion_in_entryRulePartialSequenceConstructionCompletion3317 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRulePartialSequenceConstructionCompletion3324 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PartialSequenceConstructionCompletion__Group__0_in_rulePartialSequenceConstructionCompletion3350 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceConstructionExpression_in_entryRuleSequenceConstructionExpression3377 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSequenceConstructionExpression3384 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group__0_in_ruleSequenceConstructionExpression3410 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceElement_in_entryRuleSequenceElement3437 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSequenceElement3444 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceElement__Alternatives_in_ruleSequenceElement3470 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassExtentExpression_in_entryRuleClassExtentExpression3497 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleClassExtentExpression3504 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassExtentExpression__Group__0_in_ruleClassExtentExpression3530 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBlock_in_entryRuleBlock3557 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleBlock3564 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Block__Group__0_in_ruleBlock3590 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleStatementSequence_in_entryRuleStatementSequence3617 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleStatementSequence3624 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__StatementSequence__StatementsAssignment_in_ruleStatementSequence3652 = new BitSet(new long[]{0x0000000000003132L,0x00007B93C8F00000L});

+    public static final BitSet FOLLOW_rule__StatementSequence__StatementsAssignment_in_ruleStatementSequence3664 = new BitSet(new long[]{0x0000000000003132L,0x00007B93C8F00000L});

+    public static final BitSet FOLLOW_ruleDocumentedStatement_in_entryRuleDocumentedStatement3694 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleDocumentedStatement3701 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DocumentedStatement__Group__0_in_ruleDocumentedStatement3727 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInlineStatement_in_entryRuleInlineStatement3754 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleInlineStatement3761 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__0_in_ruleInlineStatement3787 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAnnotatedStatement_in_entryRuleAnnotatedStatement3814 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleAnnotatedStatement3821 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AnnotatedStatement__Group__0_in_ruleAnnotatedStatement3847 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleStatement_in_entryRuleStatement3874 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleStatement3881 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Statement__Alternatives_in_ruleStatement3907 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAnnotation_in_entryRuleAnnotation3934 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleAnnotation3941 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Annotation__Group__0_in_ruleAnnotation3967 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBlockStatement_in_entryRuleBlockStatement3994 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleBlockStatement4001 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__BlockStatement__BlockAssignment_in_ruleBlockStatement4027 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleEmptyStatement_in_entryRuleEmptyStatement4054 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleEmptyStatement4061 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__EmptyStatement__Group__0_in_ruleEmptyStatement4087 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLocalNameDeclarationStatement_in_entryRuleLocalNameDeclarationStatement4114 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleLocalNameDeclarationStatement4121 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__0_in_ruleLocalNameDeclarationStatement4147 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleIfStatement_in_entryRuleIfStatement4174 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleIfStatement4181 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IfStatement__Group__0_in_ruleIfStatement4207 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequentialClauses_in_entryRuleSequentialClauses4234 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSequentialClauses4241 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequentialClauses__Group__0_in_ruleSequentialClauses4267 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleConcurrentClauses_in_entryRuleConcurrentClauses4294 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleConcurrentClauses4301 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConcurrentClauses__Group__0_in_ruleConcurrentClauses4327 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNonFinalClause_in_entryRuleNonFinalClause4354 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleNonFinalClause4361 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NonFinalClause__Group__0_in_ruleNonFinalClause4387 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleFinalClause_in_entryRuleFinalClause4414 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleFinalClause4421 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__FinalClause__Group__0_in_ruleFinalClause4447 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSwitchStatement_in_entryRuleSwitchStatement4474 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSwitchStatement4481 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__0_in_ruleSwitchStatement4507 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSwitchClause_in_entryRuleSwitchClause4534 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSwitchClause4541 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchClause__Group__0_in_ruleSwitchClause4567 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSwitchCase_in_entryRuleSwitchCase4594 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSwitchCase4601 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchCase__Group__0_in_ruleSwitchCase4627 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSwitchDefaultClause_in_entryRuleSwitchDefaultClause4654 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSwitchDefaultClause4661 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchDefaultClause__Group__0_in_ruleSwitchDefaultClause4687 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNonEmptyStatementSequence_in_entryRuleNonEmptyStatementSequence4714 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleNonEmptyStatementSequence4721 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NonEmptyStatementSequence__StatementAssignment_in_ruleNonEmptyStatementSequence4749 = new BitSet(new long[]{0x0000000000003132L,0x00007B93C8F00000L});

+    public static final BitSet FOLLOW_rule__NonEmptyStatementSequence__StatementAssignment_in_ruleNonEmptyStatementSequence4761 = new BitSet(new long[]{0x0000000000003132L,0x00007B93C8F00000L});

+    public static final BitSet FOLLOW_ruleWhileStatement_in_entryRuleWhileStatement4791 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleWhileStatement4798 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__WhileStatement__Group__0_in_ruleWhileStatement4824 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleDoStatement_in_entryRuleDoStatement4851 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleDoStatement4858 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__0_in_ruleDoStatement4884 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleForStatement_in_entryRuleForStatement4911 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleForStatement4918 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForStatement__Group__0_in_ruleForStatement4944 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleForControl_in_entryRuleForControl4971 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleForControl4978 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForControl__Group__0_in_ruleForControl5004 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLoopVariableDefinition_in_entryRuleLoopVariableDefinition5031 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleLoopVariableDefinition5038 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Alternatives_in_ruleLoopVariableDefinition5064 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBreakStatement_in_entryRuleBreakStatement5091 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleBreakStatement5098 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__BreakStatement__Group__0_in_ruleBreakStatement5124 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleReturnStatement_in_entryRuleReturnStatement5151 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleReturnStatement5158 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ReturnStatement__Group__0_in_ruleReturnStatement5184 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAcceptStatement_in_entryRuleAcceptStatement5211 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleAcceptStatement5218 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptStatement__Group__0_in_ruleAcceptStatement5244 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSimpleAcceptStatementCompletion_in_entryRuleSimpleAcceptStatementCompletion5271 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSimpleAcceptStatementCompletion5278 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SimpleAcceptStatementCompletion__Group__0_in_ruleSimpleAcceptStatementCompletion5304 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleCompoundAcceptStatementCompletion_in_entryRuleCompoundAcceptStatementCompletion5331 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleCompoundAcceptStatementCompletion5338 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CompoundAcceptStatementCompletion__Group__0_in_ruleCompoundAcceptStatementCompletion5364 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAcceptBlock_in_entryRuleAcceptBlock5391 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleAcceptBlock5398 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptBlock__Group__0_in_ruleAcceptBlock5424 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAcceptClause_in_entryRuleAcceptClause5451 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleAcceptClause5458 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group__0_in_ruleAcceptClause5484 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassifyStatement_in_entryRuleClassifyStatement5511 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleClassifyStatement5518 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassifyStatement__Group__0_in_ruleClassifyStatement5544 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassificationClause_in_entryRuleClassificationClause5571 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleClassificationClause5578 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationClause__Alternatives_in_ruleClassificationClause5604 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassificationFromClause_in_entryRuleClassificationFromClause5631 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleClassificationFromClause5638 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationFromClause__Group__0_in_ruleClassificationFromClause5664 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassificationToClause_in_entryRuleClassificationToClause5691 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleClassificationToClause5698 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationToClause__Group__0_in_ruleClassificationToClause5724 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleReclassifyAllClause_in_entryRuleReclassifyAllClause5751 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleReclassifyAllClause5758 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ReclassifyAllClause__Group__0_in_ruleReclassifyAllClause5784 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameList_in_entryRuleQualifiedNameList5811 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleQualifiedNameList5818 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameList__Group__0_in_ruleQualifiedNameList5844 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInvocationOrAssignementOrDeclarationStatement_in_entryRuleInvocationOrAssignementOrDeclarationStatement5871 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleInvocationOrAssignementOrDeclarationStatement5878 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Group__0_in_ruleInvocationOrAssignementOrDeclarationStatement5904 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuperInvocationStatement_in_entryRuleSuperInvocationStatement5931 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleSuperInvocationStatement5938 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationStatement__Group__0_in_ruleSuperInvocationStatement5964 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleThisInvocationStatement_in_entryRuleThisInvocationStatement5991 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleThisInvocationStatement5998 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ThisInvocationStatement__Group__0_in_ruleThisInvocationStatement6024 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInstanceCreationInvocationStatement_in_entryRuleInstanceCreationInvocationStatement6051 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleInstanceCreationInvocationStatement6058 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationInvocationStatement__Group__0_in_ruleInstanceCreationInvocationStatement6084 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleVariableDeclarationCompletion_in_entryRuleVariableDeclarationCompletion6111 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleVariableDeclarationCompletion6118 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__VariableDeclarationCompletion__Group__0_in_ruleVariableDeclarationCompletion6144 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAssignmentCompletion_in_entryRuleAssignmentCompletion6171 = new BitSet(new long[]{0x0000000000000000L});

+    public static final BitSet FOLLOW_EOF_in_entryRuleAssignmentCompletion6178 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AssignmentCompletion__Group__0_in_ruleAssignmentCompletion6204 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__BooleanValue__Alternatives_in_ruleBooleanValue6241 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationKind__Alternatives_in_ruleLinkOperationKind6277 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperator__Alternatives_in_ruleSelectOrRejectOperator6313 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperator__Alternatives_in_ruleCollectOrIterateOperator6349 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperator__Alternatives_in_ruleForAllOrExistsOrOneOperator6385 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AnnotationKind__Alternatives_in_ruleAnnotationKind6421 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AssignmentOperator__Alternatives_in_ruleAssignmentOperator6457 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBOOLEAN_LITERAL_in_rule__LITERAL__Alternatives6492 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNUMBER_LITERAL_in_rule__LITERAL__Alternatives6509 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSTRING_LITERAL_in_rule__LITERAL__Alternatives6526 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleINTEGER_LITERAL_in_rule__NUMBER_LITERAL__Alternatives6558 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleUNLIMITED_LITERAL_in_rule__NUMBER_LITERAL__Alternatives6575 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group_0_0__0_in_rule__NameExpression__Alternatives_06607 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group_0_1__0_in_rule__NameExpression__Alternatives_06625 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_12_in_rule__NameExpression__PrefixOpAlternatives_0_0_0_06659 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_13_in_rule__NameExpression__PrefixOpAlternatives_0_0_0_06679 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__InvocationCompletionAssignment_0_1_2_0_in_rule__NameExpression__Alternatives_0_1_26713 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_1_in_rule__NameExpression__Alternatives_0_1_26731 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__PostfixOpAssignment_0_1_2_2_in_rule__NameExpression__Alternatives_0_1_26749 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_12_in_rule__NameExpression__PostfixOpAlternatives_0_1_2_2_06783 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_13_in_rule__NameExpression__PostfixOpAlternatives_0_1_2_2_06803 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_14_in_rule__EqualityExpression__OpAlternatives_1_0_06838 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_15_in_rule__EqualityExpression__OpAlternatives_1_0_06858 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_16_in_rule__ClassificationExpression__OpAlternatives_1_0_06893 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_17_in_rule__ClassificationExpression__OpAlternatives_1_0_06913 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_18_in_rule__RelationalExpression__OpAlternatives_1_0_06948 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_19_in_rule__RelationalExpression__OpAlternatives_1_0_06968 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_20_in_rule__RelationalExpression__OpAlternatives_1_0_06988 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_21_in_rule__RelationalExpression__OpAlternatives_1_0_07008 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_22_in_rule__ShiftExpression__OpAlternatives_1_0_07043 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_23_in_rule__ShiftExpression__OpAlternatives_1_0_07063 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_24_in_rule__ShiftExpression__OpAlternatives_1_0_07083 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_25_in_rule__AdditiveExpression__OpAlternatives_1_0_07118 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_26_in_rule__AdditiveExpression__OpAlternatives_1_0_07138 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_27_in_rule__MultiplicativeExpression__OpAlternatives_1_0_07173 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_28_in_rule__MultiplicativeExpression__OpAlternatives_1_0_07193 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_29_in_rule__MultiplicativeExpression__OpAlternatives_1_0_07213 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_30_in_rule__UnaryExpression__OpAlternatives_0_07248 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_26_in_rule__UnaryExpression__OpAlternatives_0_07268 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_25_in_rule__UnaryExpression__OpAlternatives_0_07288 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_31_in_rule__UnaryExpression__OpAlternatives_0_07308 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_32_in_rule__UnaryExpression__OpAlternatives_0_07328 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleOperationCallExpression_in_rule__SuffixExpression__Alternatives7362 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rulePropertyCallExpression_in_rule__SuffixExpression__Alternatives7379 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLinkOperationExpression_in_rule__SuffixExpression__Alternatives7396 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceOperationExpression_in_rule__SuffixExpression__Alternatives7413 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceReductionExpression_in_rule__SuffixExpression__Alternatives7430 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceExpansionExpression_in_rule__SuffixExpression__Alternatives7447 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassExtentExpression_in_rule__SuffixExpression__Alternatives7464 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSelectOrRejectOperation_in_rule__SequenceExpansionExpression__Alternatives7496 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleCollectOrIterateOperation_in_rule__SequenceExpansionExpression__Alternatives7513 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleForAllOrExistsOrOneOperation_in_rule__SequenceExpansionExpression__Alternatives7530 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleIsUniqueOperation_in_rule__SequenceExpansionExpression__Alternatives7547 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNameExpression_in_rule__ValueSpecification__Alternatives7579 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLITERAL_in_rule__ValueSpecification__Alternatives7596 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleThisExpression_in_rule__ValueSpecification__Alternatives7613 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuperInvocationExpression_in_rule__ValueSpecification__Alternatives7630 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInstanceCreationExpression_in_rule__ValueSpecification__Alternatives7647 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleParenthesizedExpression_in_rule__ValueSpecification__Alternatives7664 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNullExpression_in_rule__ValueSpecification__Alternatives7681 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNameExpression_in_rule__NonLiteralValueSpecification__Alternatives7713 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleParenthesizedExpression_in_rule__NonLiteralValueSpecification__Alternatives7730 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInstanceCreationExpression_in_rule__NonLiteralValueSpecification__Alternatives7747 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleThisExpression_in_rule__NonLiteralValueSpecification__Alternatives7764 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuperInvocationExpression_in_rule__NonLiteralValueSpecification__Alternatives7781 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ParenthesizedExpression__CastedAssignment_3_0_in_rule__ParenthesizedExpression__Alternatives_37813 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ParenthesizedExpression__SuffixAssignment_3_1_in_rule__ParenthesizedExpression__Alternatives_37831 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__TupleAssignment_1_0_in_rule__SuperInvocationExpression__Alternatives_17864 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__Group_1_1__0_in_rule__SuperInvocationExpression__Alternatives_17882 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionOrAccessCompletion__Group_0__0_in_rule__SequenceConstructionOrAccessCompletion__Alternatives7915 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_1_in_rule__SequenceConstructionOrAccessCompletion__Alternatives7933 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_0_in_rule__SequenceConstructionOrAccessCompletion__Alternatives_0_17966 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_1_in_rule__SequenceConstructionOrAccessCompletion__Alternatives_0_17984 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group_2_0__0_in_rule__SequenceConstructionExpression__Alternatives_28017 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group_2_1__0_in_rule__SequenceConstructionExpression__Alternatives_28036 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__SequenceElement__Alternatives8069 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceConstructionExpression_in_rule__SequenceElement__Alternatives8086 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ML_COMMENT_in_rule__DocumentedStatement__CommentAlternatives_0_08118 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_SL_COMMENT_in_rule__DocumentedStatement__CommentAlternatives_0_08135 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAnnotatedStatement_in_rule__Statement__Alternatives8167 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInlineStatement_in_rule__Statement__Alternatives8184 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBlockStatement_in_rule__Statement__Alternatives8201 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleEmptyStatement_in_rule__Statement__Alternatives8218 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLocalNameDeclarationStatement_in_rule__Statement__Alternatives8235 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleIfStatement_in_rule__Statement__Alternatives8252 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSwitchStatement_in_rule__Statement__Alternatives8269 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleWhileStatement_in_rule__Statement__Alternatives8286 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleDoStatement_in_rule__Statement__Alternatives8303 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleForStatement_in_rule__Statement__Alternatives8320 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBreakStatement_in_rule__Statement__Alternatives8337 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleReturnStatement_in_rule__Statement__Alternatives8354 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAcceptStatement_in_rule__Statement__Alternatives8371 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassifyStatement_in_rule__Statement__Alternatives8388 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInvocationOrAssignementOrDeclarationStatement_in_rule__Statement__Alternatives8405 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuperInvocationStatement_in_rule__Statement__Alternatives8422 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleThisInvocationStatement_in_rule__Statement__Alternatives8439 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInstanceCreationInvocationStatement_in_rule__Statement__Alternatives8456 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_0__0_in_rule__LoopVariableDefinition__Alternatives8488 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_1__0_in_rule__LoopVariableDefinition__Alternatives8506 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptStatement__SimpleAcceptAssignment_1_0_in_rule__AcceptStatement__Alternatives_18539 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptStatement__CompoundAcceptAssignment_1_1_in_rule__AcceptStatement__Alternatives_18557 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationClause__Group_0__0_in_rule__ClassificationClause__Alternatives8590 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationClause__Group_1__0_in_rule__ClassificationClause__Alternatives8608 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_0_in_rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_18641 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_1_in_rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_18659 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_33_in_rule__BooleanValue__Alternatives8693 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_34_in_rule__BooleanValue__Alternatives8714 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_35_in_rule__LinkOperationKind__Alternatives8750 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_36_in_rule__LinkOperationKind__Alternatives8771 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_37_in_rule__LinkOperationKind__Alternatives8792 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_38_in_rule__SelectOrRejectOperator__Alternatives8828 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_39_in_rule__SelectOrRejectOperator__Alternatives8849 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_40_in_rule__CollectOrIterateOperator__Alternatives8885 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_41_in_rule__CollectOrIterateOperator__Alternatives8906 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_42_in_rule__ForAllOrExistsOrOneOperator__Alternatives8942 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_43_in_rule__ForAllOrExistsOrOneOperator__Alternatives8963 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_44_in_rule__ForAllOrExistsOrOneOperator__Alternatives8984 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_45_in_rule__AnnotationKind__Alternatives9020 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_46_in_rule__AnnotationKind__Alternatives9041 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_47_in_rule__AnnotationKind__Alternatives9062 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_48_in_rule__AnnotationKind__Alternatives9083 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_49_in_rule__AssignmentOperator__Alternatives9119 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_50_in_rule__AssignmentOperator__Alternatives9140 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_51_in_rule__AssignmentOperator__Alternatives9161 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_52_in_rule__AssignmentOperator__Alternatives9182 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_53_in_rule__AssignmentOperator__Alternatives9203 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_54_in_rule__AssignmentOperator__Alternatives9224 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_55_in_rule__AssignmentOperator__Alternatives9245 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_56_in_rule__AssignmentOperator__Alternatives9266 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_57_in_rule__AssignmentOperator__Alternatives9287 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_58_in_rule__AssignmentOperator__Alternatives9308 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_59_in_rule__AssignmentOperator__Alternatives9329 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_60_in_rule__AssignmentOperator__Alternatives9350 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group__0__Impl_in_rule__Test__Group__09383 = new BitSet(new long[]{0xC000000000000000L,0x0000000000000001L});

+    public static final BitSet FOLLOW_rule__Test__Group__1_in_rule__Test__Group__09386 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group_0__0_in_rule__Test__Group__0__Impl9413 = new BitSet(new long[]{0x2000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group__1__Impl_in_rule__Test__Group__19444 = new BitSet(new long[]{0xC000000000000000L,0x0000000000000001L});

+    public static final BitSet FOLLOW_rule__Test__Group__2_in_rule__Test__Group__19447 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group_1__0_in_rule__Test__Group__1__Impl9474 = new BitSet(new long[]{0x4000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group__2__Impl_in_rule__Test__Group__29505 = new BitSet(new long[]{0xC000000000000000L,0x0000000000000001L});

+    public static final BitSet FOLLOW_rule__Test__Group__3_in_rule__Test__Group__29508 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group_2__0_in_rule__Test__Group__2__Impl9535 = new BitSet(new long[]{0x8000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group__3__Impl_in_rule__Test__Group__39566 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group_3__0_in_rule__Test__Group__3__Impl9593 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group_0__0__Impl_in_rule__Test__Group_0__09631 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__Test__Group_0__1_in_rule__Test__Group_0__09634 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_61_in_rule__Test__Group_0__0__Impl9662 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group_0__1__Impl_in_rule__Test__Group_0__19693 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__ExpressionAssignment_0_1_in_rule__Test__Group_0__1__Impl9720 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group_1__0__Impl_in_rule__Test__Group_1__09754 = new BitSet(new long[]{0x1FFE000000000000L});

+    public static final BitSet FOLLOW_rule__Test__Group_1__1_in_rule__Test__Group_1__09757 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_62_in_rule__Test__Group_1__0__Impl9785 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group_1__1__Impl_in_rule__Test__Group_1__19816 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__AssignExpressionAssignment_1_1_in_rule__Test__Group_1__1__Impl9843 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group_2__0__Impl_in_rule__Test__Group_2__09877 = new BitSet(new long[]{0x0000000000003130L,0x00007B93C8F00000L});

+    public static final BitSet FOLLOW_rule__Test__Group_2__1_in_rule__Test__Group_2__09880 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_63_in_rule__Test__Group_2__0__Impl9908 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group_2__1__Impl_in_rule__Test__Group_2__19939 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__StatementsAssignment_2_1_in_rule__Test__Group_2__1__Impl9966 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group_3__0__Impl_in_rule__Test__Group_3__010000 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});

+    public static final BitSet FOLLOW_rule__Test__Group_3__1_in_rule__Test__Group_3__010003 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_64_in_rule__Test__Group_3__0__Impl10031 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__Group_3__1__Impl_in_rule__Test__Group_3__110062 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Test__BlockAssignment_3_1_in_rule__Test__Group_3__1__Impl10089 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group__0__Impl_in_rule__NameExpression__Group__010123 = new BitSet(new long[]{0x0000000000000000L,0x0000000000012000L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group__1_in_rule__NameExpression__Group__010126 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__Alternatives_0_in_rule__NameExpression__Group__0__Impl10153 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group__1__Impl_in_rule__NameExpression__Group__110183 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__SuffixAssignment_1_in_rule__NameExpression__Group__1__Impl10210 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group_0_0__0__Impl_in_rule__NameExpression__Group_0_0__010245 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group_0_0__1_in_rule__NameExpression__Group_0_0__010248 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__PrefixOpAssignment_0_0_0_in_rule__NameExpression__Group_0_0__0__Impl10275 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group_0_0__1__Impl_in_rule__NameExpression__Group_0_0__110305 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group_0_0__2_in_rule__NameExpression__Group_0_0__110308 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__PathAssignment_0_0_1_in_rule__NameExpression__Group_0_0__1__Impl10335 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group_0_0__2__Impl_in_rule__NameExpression__Group_0_0__210366 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__IdAssignment_0_0_2_in_rule__NameExpression__Group_0_0__2__Impl10393 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group_0_1__0__Impl_in_rule__NameExpression__Group_0_1__010429 = new BitSet(new long[]{0x0000000000003100L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group_0_1__1_in_rule__NameExpression__Group_0_1__010432 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__PathAssignment_0_1_0_in_rule__NameExpression__Group_0_1__0__Impl10459 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group_0_1__1__Impl_in_rule__NameExpression__Group_0_1__110490 = new BitSet(new long[]{0x0000000000003000L,0x0000000000804010L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group_0_1__2_in_rule__NameExpression__Group_0_1__110493 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__IdAssignment_0_1_1_in_rule__NameExpression__Group_0_1__1__Impl10520 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__Group_0_1__2__Impl_in_rule__NameExpression__Group_0_1__210550 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__Alternatives_0_1_2_in_rule__NameExpression__Group_0_1__2__Impl10577 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNamePath__Group__0__Impl_in_rule__QualifiedNamePath__Group__010614 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNamePath__Group__1_in_rule__QualifiedNamePath__Group__010617 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNamePath__NamespaceAssignment_0_in_rule__QualifiedNamePath__Group__0__Impl10644 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNamePath__Group__1__Impl_in_rule__QualifiedNamePath__Group__110674 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_65_in_rule__QualifiedNamePath__Group__1__Impl10702 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__UnqualifiedName__Group__0__Impl_in_rule__UnqualifiedName__Group__010737 = new BitSet(new long[]{0x0000000000040000L});

+    public static final BitSet FOLLOW_rule__UnqualifiedName__Group__1_in_rule__UnqualifiedName__Group__010740 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__UnqualifiedName__NameAssignment_0_in_rule__UnqualifiedName__Group__0__Impl10767 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__UnqualifiedName__Group__1__Impl_in_rule__UnqualifiedName__Group__110797 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__UnqualifiedName__TemplateBindingAssignment_1_in_rule__UnqualifiedName__Group__1__Impl10824 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__Group__0__Impl_in_rule__TemplateBinding__Group__010859 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__Group__1_in_rule__TemplateBinding__Group__010862 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_18_in_rule__TemplateBinding__Group__0__Impl10890 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__Group__1__Impl_in_rule__TemplateBinding__Group__110921 = new BitSet(new long[]{0x0000000000080000L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__Group__2_in_rule__TemplateBinding__Group__110924 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__BindingsAssignment_1_in_rule__TemplateBinding__Group__1__Impl10951 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__Group__2__Impl_in_rule__TemplateBinding__Group__210981 = new BitSet(new long[]{0x0000000000080000L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__Group__3_in_rule__TemplateBinding__Group__210984 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__Group_2__0_in_rule__TemplateBinding__Group__2__Impl11011 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__Group__3__Impl_in_rule__TemplateBinding__Group__311042 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_19_in_rule__TemplateBinding__Group__3__Impl11070 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__Group_2__0__Impl_in_rule__TemplateBinding__Group_2__011109 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__Group_2__1_in_rule__TemplateBinding__Group_2__011112 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_66_in_rule__TemplateBinding__Group_2__0__Impl11140 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__Group_2__1__Impl_in_rule__TemplateBinding__Group_2__111171 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__TemplateBinding__BindingsAssignment_2_1_in_rule__TemplateBinding__Group_2__1__Impl11198 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NamedTemplateBinding__Group__0__Impl_in_rule__NamedTemplateBinding__Group__011232 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});

+    public static final BitSet FOLLOW_rule__NamedTemplateBinding__Group__1_in_rule__NamedTemplateBinding__Group__011235 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NamedTemplateBinding__FormalAssignment_0_in_rule__NamedTemplateBinding__Group__0__Impl11262 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NamedTemplateBinding__Group__1__Impl_in_rule__NamedTemplateBinding__Group__111292 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__NamedTemplateBinding__Group__2_in_rule__NamedTemplateBinding__Group__111295 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_67_in_rule__NamedTemplateBinding__Group__1__Impl11323 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NamedTemplateBinding__Group__2__Impl_in_rule__NamedTemplateBinding__Group__211354 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NamedTemplateBinding__ActualAssignment_2_in_rule__NamedTemplateBinding__Group__2__Impl11381 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameWithBinding__Group__0__Impl_in_rule__QualifiedNameWithBinding__Group__011417 = new BitSet(new long[]{0x0000000000040000L,0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameWithBinding__Group__1_in_rule__QualifiedNameWithBinding__Group__011420 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameWithBinding__IdAssignment_0_in_rule__QualifiedNameWithBinding__Group__0__Impl11447 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameWithBinding__Group__1__Impl_in_rule__QualifiedNameWithBinding__Group__111477 = new BitSet(new long[]{0x0000000000040000L,0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameWithBinding__Group__2_in_rule__QualifiedNameWithBinding__Group__111480 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameWithBinding__BindingAssignment_1_in_rule__QualifiedNameWithBinding__Group__1__Impl11507 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameWithBinding__Group__2__Impl_in_rule__QualifiedNameWithBinding__Group__211538 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameWithBinding__Group_2__0_in_rule__QualifiedNameWithBinding__Group__2__Impl11565 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameWithBinding__Group_2__0__Impl_in_rule__QualifiedNameWithBinding__Group_2__011602 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__QualifiedNameWithBinding__Group_2__1_in_rule__QualifiedNameWithBinding__Group_2__011605 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_65_in_rule__QualifiedNameWithBinding__Group_2__0__Impl11633 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameWithBinding__Group_2__1__Impl_in_rule__QualifiedNameWithBinding__Group_2__111664 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameWithBinding__RemainingAssignment_2_1_in_rule__QualifiedNameWithBinding__Group_2__1__Impl11691 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Tuple__Group__0__Impl_in_rule__Tuple__Group__011725 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__Tuple__Group__1_in_rule__Tuple__Group__011728 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Tuple__Group__1__Impl_in_rule__Tuple__Group__111786 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80030L});

+    public static final BitSet FOLLOW_rule__Tuple__Group__2_in_rule__Tuple__Group__111789 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__Tuple__Group__1__Impl11817 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Tuple__Group__2__Impl_in_rule__Tuple__Group__211848 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80030L});

+    public static final BitSet FOLLOW_rule__Tuple__Group__3_in_rule__Tuple__Group__211851 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Tuple__Group_2__0_in_rule__Tuple__Group__2__Impl11878 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Tuple__Group__3__Impl_in_rule__Tuple__Group__311909 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__Tuple__Group__3__Impl11937 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Tuple__Group_2__0__Impl_in_rule__Tuple__Group_2__011976 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__Tuple__Group_2__1_in_rule__Tuple__Group_2__011979 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Tuple__TupleElementsAssignment_2_0_in_rule__Tuple__Group_2__0__Impl12006 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Tuple__Group_2__1__Impl_in_rule__Tuple__Group_2__112036 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Tuple__Group_2_1__0_in_rule__Tuple__Group_2__1__Impl12063 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__Tuple__Group_2_1__0__Impl_in_rule__Tuple__Group_2_1__012098 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__Tuple__Group_2_1__1_in_rule__Tuple__Group_2_1__012101 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_66_in_rule__Tuple__Group_2_1__0__Impl12129 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Tuple__Group_2_1__1__Impl_in_rule__Tuple__Group_2_1__112160 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Tuple__TupleElementsAssignment_2_1_1_in_rule__Tuple__Group_2_1__1__Impl12187 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__Group__0__Impl_in_rule__ConditionalTestExpression__Group__012221 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__Group__1_in_rule__ConditionalTestExpression__Group__012224 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__ExpAssignment_0_in_rule__ConditionalTestExpression__Group__0__Impl12251 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__Group__1__Impl_in_rule__ConditionalTestExpression__Group__112281 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__Group_1__0_in_rule__ConditionalTestExpression__Group__1__Impl12308 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__Group_1__0__Impl_in_rule__ConditionalTestExpression__Group_1__012343 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__Group_1__1_in_rule__ConditionalTestExpression__Group_1__012346 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_70_in_rule__ConditionalTestExpression__Group_1__0__Impl12374 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__Group_1__1__Impl_in_rule__ConditionalTestExpression__Group_1__112405 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__Group_1__2_in_rule__ConditionalTestExpression__Group_1__112408 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__WhenTrueAssignment_1_1_in_rule__ConditionalTestExpression__Group_1__1__Impl12435 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__Group_1__2__Impl_in_rule__ConditionalTestExpression__Group_1__212465 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__Group_1__3_in_rule__ConditionalTestExpression__Group_1__212468 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_71_in_rule__ConditionalTestExpression__Group_1__2__Impl12496 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__Group_1__3__Impl_in_rule__ConditionalTestExpression__Group_1__312527 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalTestExpression__WhenFalseAssignment_1_3_in_rule__ConditionalTestExpression__Group_1__3__Impl12554 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalOrExpression__Group__0__Impl_in_rule__ConditionalOrExpression__Group__012592 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__ConditionalOrExpression__Group__1_in_rule__ConditionalOrExpression__Group__012595 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalOrExpression__ExpAssignment_0_in_rule__ConditionalOrExpression__Group__0__Impl12622 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalOrExpression__Group__1__Impl_in_rule__ConditionalOrExpression__Group__112652 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalOrExpression__Group_1__0_in_rule__ConditionalOrExpression__Group__1__Impl12679 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__ConditionalOrExpression__Group_1__0__Impl_in_rule__ConditionalOrExpression__Group_1__012714 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__ConditionalOrExpression__Group_1__1_in_rule__ConditionalOrExpression__Group_1__012717 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_72_in_rule__ConditionalOrExpression__Group_1__0__Impl12745 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalOrExpression__Group_1__1__Impl_in_rule__ConditionalOrExpression__Group_1__112776 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalOrExpression__ExpAssignment_1_1_in_rule__ConditionalOrExpression__Group_1__1__Impl12803 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalAndExpression__Group__0__Impl_in_rule__ConditionalAndExpression__Group__012837 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L});

+    public static final BitSet FOLLOW_rule__ConditionalAndExpression__Group__1_in_rule__ConditionalAndExpression__Group__012840 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalAndExpression__ExpAssignment_0_in_rule__ConditionalAndExpression__Group__0__Impl12867 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalAndExpression__Group__1__Impl_in_rule__ConditionalAndExpression__Group__112897 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalAndExpression__Group_1__0_in_rule__ConditionalAndExpression__Group__1__Impl12924 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000200L});

+    public static final BitSet FOLLOW_rule__ConditionalAndExpression__Group_1__0__Impl_in_rule__ConditionalAndExpression__Group_1__012959 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__ConditionalAndExpression__Group_1__1_in_rule__ConditionalAndExpression__Group_1__012962 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_73_in_rule__ConditionalAndExpression__Group_1__0__Impl12990 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalAndExpression__Group_1__1__Impl_in_rule__ConditionalAndExpression__Group_1__113021 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConditionalAndExpression__ExpAssignment_1_1_in_rule__ConditionalAndExpression__Group_1__1__Impl13048 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InclusiveOrExpression__Group__0__Impl_in_rule__InclusiveOrExpression__Group__013082 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});

+    public static final BitSet FOLLOW_rule__InclusiveOrExpression__Group__1_in_rule__InclusiveOrExpression__Group__013085 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InclusiveOrExpression__ExpAssignment_0_in_rule__InclusiveOrExpression__Group__0__Impl13112 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InclusiveOrExpression__Group__1__Impl_in_rule__InclusiveOrExpression__Group__113142 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InclusiveOrExpression__Group_1__0_in_rule__InclusiveOrExpression__Group__1__Impl13169 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000400L});

+    public static final BitSet FOLLOW_rule__InclusiveOrExpression__Group_1__0__Impl_in_rule__InclusiveOrExpression__Group_1__013204 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__InclusiveOrExpression__Group_1__1_in_rule__InclusiveOrExpression__Group_1__013207 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_74_in_rule__InclusiveOrExpression__Group_1__0__Impl13235 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InclusiveOrExpression__Group_1__1__Impl_in_rule__InclusiveOrExpression__Group_1__113266 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InclusiveOrExpression__ExpAssignment_1_1_in_rule__InclusiveOrExpression__Group_1__1__Impl13293 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ExclusiveOrExpression__Group__0__Impl_in_rule__ExclusiveOrExpression__Group__013327 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});

+    public static final BitSet FOLLOW_rule__ExclusiveOrExpression__Group__1_in_rule__ExclusiveOrExpression__Group__013330 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ExclusiveOrExpression__ExpAssignment_0_in_rule__ExclusiveOrExpression__Group__0__Impl13357 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ExclusiveOrExpression__Group__1__Impl_in_rule__ExclusiveOrExpression__Group__113387 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ExclusiveOrExpression__Group_1__0_in_rule__ExclusiveOrExpression__Group__1__Impl13414 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000800L});

+    public static final BitSet FOLLOW_rule__ExclusiveOrExpression__Group_1__0__Impl_in_rule__ExclusiveOrExpression__Group_1__013449 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__ExclusiveOrExpression__Group_1__1_in_rule__ExclusiveOrExpression__Group_1__013452 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_75_in_rule__ExclusiveOrExpression__Group_1__0__Impl13480 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ExclusiveOrExpression__Group_1__1__Impl_in_rule__ExclusiveOrExpression__Group_1__113511 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ExclusiveOrExpression__ExpAssignment_1_1_in_rule__ExclusiveOrExpression__Group_1__1__Impl13538 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AndExpression__Group__0__Impl_in_rule__AndExpression__Group__013572 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});

+    public static final BitSet FOLLOW_rule__AndExpression__Group__1_in_rule__AndExpression__Group__013575 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AndExpression__ExpAssignment_0_in_rule__AndExpression__Group__0__Impl13602 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AndExpression__Group__1__Impl_in_rule__AndExpression__Group__113632 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AndExpression__Group_1__0_in_rule__AndExpression__Group__1__Impl13659 = new BitSet(new long[]{0x0000000000000002L,0x0000000000001000L});

+    public static final BitSet FOLLOW_rule__AndExpression__Group_1__0__Impl_in_rule__AndExpression__Group_1__013694 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__AndExpression__Group_1__1_in_rule__AndExpression__Group_1__013697 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_76_in_rule__AndExpression__Group_1__0__Impl13725 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AndExpression__Group_1__1__Impl_in_rule__AndExpression__Group_1__113756 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AndExpression__ExpAssignment_1_1_in_rule__AndExpression__Group_1__1__Impl13783 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__EqualityExpression__Group__0__Impl_in_rule__EqualityExpression__Group__013817 = new BitSet(new long[]{0x000000000000C000L});

+    public static final BitSet FOLLOW_rule__EqualityExpression__Group__1_in_rule__EqualityExpression__Group__013820 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__EqualityExpression__ExpAssignment_0_in_rule__EqualityExpression__Group__0__Impl13847 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__EqualityExpression__Group__1__Impl_in_rule__EqualityExpression__Group__113877 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__EqualityExpression__Group_1__0_in_rule__EqualityExpression__Group__1__Impl13904 = new BitSet(new long[]{0x000000000000C002L});

+    public static final BitSet FOLLOW_rule__EqualityExpression__Group_1__0__Impl_in_rule__EqualityExpression__Group_1__013939 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__EqualityExpression__Group_1__1_in_rule__EqualityExpression__Group_1__013942 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__EqualityExpression__OpAssignment_1_0_in_rule__EqualityExpression__Group_1__0__Impl13969 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__EqualityExpression__Group_1__1__Impl_in_rule__EqualityExpression__Group_1__113999 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__EqualityExpression__ExpAssignment_1_1_in_rule__EqualityExpression__Group_1__1__Impl14026 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationExpression__Group__0__Impl_in_rule__ClassificationExpression__Group__014060 = new BitSet(new long[]{0x0000000000030000L});

+    public static final BitSet FOLLOW_rule__ClassificationExpression__Group__1_in_rule__ClassificationExpression__Group__014063 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationExpression__ExpAssignment_0_in_rule__ClassificationExpression__Group__0__Impl14090 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationExpression__Group__1__Impl_in_rule__ClassificationExpression__Group__114120 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationExpression__Group_1__0_in_rule__ClassificationExpression__Group__1__Impl14147 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationExpression__Group_1__0__Impl_in_rule__ClassificationExpression__Group_1__014182 = new BitSet(new long[]{0x0000000000003100L});

+    public static final BitSet FOLLOW_rule__ClassificationExpression__Group_1__1_in_rule__ClassificationExpression__Group_1__014185 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationExpression__OpAssignment_1_0_in_rule__ClassificationExpression__Group_1__0__Impl14212 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationExpression__Group_1__1__Impl_in_rule__ClassificationExpression__Group_1__114242 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationExpression__TypeNameAssignment_1_1_in_rule__ClassificationExpression__Group_1__1__Impl14269 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__RelationalExpression__Group__0__Impl_in_rule__RelationalExpression__Group__014303 = new BitSet(new long[]{0x00000000003C0000L});

+    public static final BitSet FOLLOW_rule__RelationalExpression__Group__1_in_rule__RelationalExpression__Group__014306 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__RelationalExpression__LeftAssignment_0_in_rule__RelationalExpression__Group__0__Impl14333 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__RelationalExpression__Group__1__Impl_in_rule__RelationalExpression__Group__114363 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__RelationalExpression__Group_1__0_in_rule__RelationalExpression__Group__1__Impl14390 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__RelationalExpression__Group_1__0__Impl_in_rule__RelationalExpression__Group_1__014425 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__RelationalExpression__Group_1__1_in_rule__RelationalExpression__Group_1__014428 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__RelationalExpression__OpAssignment_1_0_in_rule__RelationalExpression__Group_1__0__Impl14455 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__RelationalExpression__Group_1__1__Impl_in_rule__RelationalExpression__Group_1__114485 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__RelationalExpression__RightAssignment_1_1_in_rule__RelationalExpression__Group_1__1__Impl14512 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ShiftExpression__Group__0__Impl_in_rule__ShiftExpression__Group__014546 = new BitSet(new long[]{0x0000000001C00000L});

+    public static final BitSet FOLLOW_rule__ShiftExpression__Group__1_in_rule__ShiftExpression__Group__014549 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ShiftExpression__ExpAssignment_0_in_rule__ShiftExpression__Group__0__Impl14576 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ShiftExpression__Group__1__Impl_in_rule__ShiftExpression__Group__114606 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ShiftExpression__Group_1__0_in_rule__ShiftExpression__Group__1__Impl14633 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ShiftExpression__Group_1__0__Impl_in_rule__ShiftExpression__Group_1__014668 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__ShiftExpression__Group_1__1_in_rule__ShiftExpression__Group_1__014671 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ShiftExpression__OpAssignment_1_0_in_rule__ShiftExpression__Group_1__0__Impl14698 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ShiftExpression__Group_1__1__Impl_in_rule__ShiftExpression__Group_1__114728 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ShiftExpression__ExpAssignment_1_1_in_rule__ShiftExpression__Group_1__1__Impl14755 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AdditiveExpression__Group__0__Impl_in_rule__AdditiveExpression__Group__014789 = new BitSet(new long[]{0x0000000006000000L});

+    public static final BitSet FOLLOW_rule__AdditiveExpression__Group__1_in_rule__AdditiveExpression__Group__014792 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AdditiveExpression__ExpAssignment_0_in_rule__AdditiveExpression__Group__0__Impl14819 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AdditiveExpression__Group__1__Impl_in_rule__AdditiveExpression__Group__114849 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AdditiveExpression__Group_1__0_in_rule__AdditiveExpression__Group__1__Impl14876 = new BitSet(new long[]{0x0000000006000002L});

+    public static final BitSet FOLLOW_rule__AdditiveExpression__Group_1__0__Impl_in_rule__AdditiveExpression__Group_1__014911 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__AdditiveExpression__Group_1__1_in_rule__AdditiveExpression__Group_1__014914 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AdditiveExpression__OpAssignment_1_0_in_rule__AdditiveExpression__Group_1__0__Impl14941 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AdditiveExpression__Group_1__1__Impl_in_rule__AdditiveExpression__Group_1__114971 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AdditiveExpression__ExpAssignment_1_1_in_rule__AdditiveExpression__Group_1__1__Impl14998 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__MultiplicativeExpression__Group__0__Impl_in_rule__MultiplicativeExpression__Group__015032 = new BitSet(new long[]{0x0000000038000000L});

+    public static final BitSet FOLLOW_rule__MultiplicativeExpression__Group__1_in_rule__MultiplicativeExpression__Group__015035 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__MultiplicativeExpression__ExpAssignment_0_in_rule__MultiplicativeExpression__Group__0__Impl15062 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__MultiplicativeExpression__Group__1__Impl_in_rule__MultiplicativeExpression__Group__115092 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__MultiplicativeExpression__Group_1__0_in_rule__MultiplicativeExpression__Group__1__Impl15119 = new BitSet(new long[]{0x0000000038000002L});

+    public static final BitSet FOLLOW_rule__MultiplicativeExpression__Group_1__0__Impl_in_rule__MultiplicativeExpression__Group_1__015154 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__MultiplicativeExpression__Group_1__1_in_rule__MultiplicativeExpression__Group_1__015157 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__MultiplicativeExpression__OpAssignment_1_0_in_rule__MultiplicativeExpression__Group_1__0__Impl15184 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__MultiplicativeExpression__Group_1__1__Impl_in_rule__MultiplicativeExpression__Group_1__115214 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__MultiplicativeExpression__ExpAssignment_1_1_in_rule__MultiplicativeExpression__Group_1__1__Impl15241 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__UnaryExpression__Group__0__Impl_in_rule__UnaryExpression__Group__015275 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__UnaryExpression__Group__1_in_rule__UnaryExpression__Group__015278 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__UnaryExpression__OpAssignment_0_in_rule__UnaryExpression__Group__0__Impl15305 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__UnaryExpression__Group__1__Impl_in_rule__UnaryExpression__Group__115336 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__UnaryExpression__ExpAssignment_1_in_rule__UnaryExpression__Group__1__Impl15363 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__OperationCallExpression__Group__0__Impl_in_rule__OperationCallExpression__Group__015397 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__OperationCallExpression__Group__1_in_rule__OperationCallExpression__Group__015400 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_77_in_rule__OperationCallExpression__Group__0__Impl15428 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__OperationCallExpression__Group__1__Impl_in_rule__OperationCallExpression__Group__115459 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__OperationCallExpression__Group__2_in_rule__OperationCallExpression__Group__115462 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__OperationCallExpression__OperationNameAssignment_1_in_rule__OperationCallExpression__Group__1__Impl15489 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__OperationCallExpression__Group__2__Impl_in_rule__OperationCallExpression__Group__215519 = new BitSet(new long[]{0x0000000000000000L,0x0000000000012000L});

+    public static final BitSet FOLLOW_rule__OperationCallExpression__Group__3_in_rule__OperationCallExpression__Group__215522 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__OperationCallExpression__TupleAssignment_2_in_rule__OperationCallExpression__Group__2__Impl15549 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__OperationCallExpression__Group__3__Impl_in_rule__OperationCallExpression__Group__315579 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__OperationCallExpression__SuffixAssignment_3_in_rule__OperationCallExpression__Group__3__Impl15606 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group__0__Impl_in_rule__PropertyCallExpression__Group__015645 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group__1_in_rule__PropertyCallExpression__Group__015648 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_77_in_rule__PropertyCallExpression__Group__0__Impl15676 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group__1__Impl_in_rule__PropertyCallExpression__Group__115707 = new BitSet(new long[]{0x0000000000000000L,0x0000000000016000L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group__2_in_rule__PropertyCallExpression__Group__115710 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__PropertyNameAssignment_1_in_rule__PropertyCallExpression__Group__1__Impl15737 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group__2__Impl_in_rule__PropertyCallExpression__Group__215767 = new BitSet(new long[]{0x0000000000000000L,0x0000000000016000L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group__3_in_rule__PropertyCallExpression__Group__215770 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group_2__0_in_rule__PropertyCallExpression__Group__2__Impl15797 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group__3__Impl_in_rule__PropertyCallExpression__Group__315828 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__SuffixAssignment_3_in_rule__PropertyCallExpression__Group__3__Impl15855 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group_2__0__Impl_in_rule__PropertyCallExpression__Group_2__015894 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group_2__1_in_rule__PropertyCallExpression__Group_2__015897 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_78_in_rule__PropertyCallExpression__Group_2__0__Impl15925 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group_2__1__Impl_in_rule__PropertyCallExpression__Group_2__115956 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group_2__2_in_rule__PropertyCallExpression__Group_2__115959 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__IndexAssignment_2_1_in_rule__PropertyCallExpression__Group_2__1__Impl15986 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PropertyCallExpression__Group_2__2__Impl_in_rule__PropertyCallExpression__Group_2__216016 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_79_in_rule__PropertyCallExpression__Group_2__2__Impl16044 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationExpression__Group__0__Impl_in_rule__LinkOperationExpression__Group__016081 = new BitSet(new long[]{0x0000003800000000L});

+    public static final BitSet FOLLOW_rule__LinkOperationExpression__Group__1_in_rule__LinkOperationExpression__Group__016084 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_77_in_rule__LinkOperationExpression__Group__0__Impl16112 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationExpression__Group__1__Impl_in_rule__LinkOperationExpression__Group__116143 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__LinkOperationExpression__Group__2_in_rule__LinkOperationExpression__Group__116146 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationExpression__KindAssignment_1_in_rule__LinkOperationExpression__Group__1__Impl16173 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationExpression__Group__2__Impl_in_rule__LinkOperationExpression__Group__216203 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationExpression__TupleAssignment_2_in_rule__LinkOperationExpression__Group__2__Impl16230 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__Group__0__Impl_in_rule__LinkOperationTuple__Group__016266 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__Group__1_in_rule__LinkOperationTuple__Group__016269 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__LinkOperationTuple__Group__0__Impl16297 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__Group__1__Impl_in_rule__LinkOperationTuple__Group__116328 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000024L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__Group__2_in_rule__LinkOperationTuple__Group__116331 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__LinkOperationTupleElementAssignment_1_in_rule__LinkOperationTuple__Group__1__Impl16358 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__Group__2__Impl_in_rule__LinkOperationTuple__Group__216388 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000024L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__Group__3_in_rule__LinkOperationTuple__Group__216391 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__Group_2__0_in_rule__LinkOperationTuple__Group__2__Impl16418 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__Group__3__Impl_in_rule__LinkOperationTuple__Group__316449 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__LinkOperationTuple__Group__3__Impl16477 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__Group_2__0__Impl_in_rule__LinkOperationTuple__Group_2__016516 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__Group_2__1_in_rule__LinkOperationTuple__Group_2__016519 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_66_in_rule__LinkOperationTuple__Group_2__0__Impl16547 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__Group_2__1__Impl_in_rule__LinkOperationTuple__Group_2__116578 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_1_in_rule__LinkOperationTuple__Group_2__1__Impl16605 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group__0__Impl_in_rule__LinkOperationTupleElement__Group__016639 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004008L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group__1_in_rule__LinkOperationTupleElement__Group__016642 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__RoleAssignment_0_in_rule__LinkOperationTupleElement__Group__0__Impl16669 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group__1__Impl_in_rule__LinkOperationTupleElement__Group__116699 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004008L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group__2_in_rule__LinkOperationTupleElement__Group__116702 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group_1__0_in_rule__LinkOperationTupleElement__Group__1__Impl16729 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group__2__Impl_in_rule__LinkOperationTupleElement__Group__216760 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group__3_in_rule__LinkOperationTupleElement__Group__216763 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_67_in_rule__LinkOperationTupleElement__Group__2__Impl16791 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group__3__Impl_in_rule__LinkOperationTupleElement__Group__316822 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__ObjectAssignment_3_in_rule__LinkOperationTupleElement__Group__3__Impl16849 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group_1__0__Impl_in_rule__LinkOperationTupleElement__Group_1__016887 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group_1__1_in_rule__LinkOperationTupleElement__Group_1__016890 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_78_in_rule__LinkOperationTupleElement__Group_1__0__Impl16918 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group_1__1__Impl_in_rule__LinkOperationTupleElement__Group_1__116949 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group_1__2_in_rule__LinkOperationTupleElement__Group_1__116952 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__RoleIndexAssignment_1_1_in_rule__LinkOperationTupleElement__Group_1__1__Impl16979 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LinkOperationTupleElement__Group_1__2__Impl_in_rule__LinkOperationTupleElement__Group_1__217009 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_79_in_rule__LinkOperationTupleElement__Group_1__2__Impl17037 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceOperationExpression__Group__0__Impl_in_rule__SequenceOperationExpression__Group__017074 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__SequenceOperationExpression__Group__1_in_rule__SequenceOperationExpression__Group__017077 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_80_in_rule__SequenceOperationExpression__Group__0__Impl17105 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceOperationExpression__Group__1__Impl_in_rule__SequenceOperationExpression__Group__117136 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__SequenceOperationExpression__Group__2_in_rule__SequenceOperationExpression__Group__117139 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceOperationExpression__OperationNameAssignment_1_in_rule__SequenceOperationExpression__Group__1__Impl17166 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceOperationExpression__Group__2__Impl_in_rule__SequenceOperationExpression__Group__217196 = new BitSet(new long[]{0x0000000000000000L,0x0000000000012000L});

+    public static final BitSet FOLLOW_rule__SequenceOperationExpression__Group__3_in_rule__SequenceOperationExpression__Group__217199 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceOperationExpression__TupleAssignment_2_in_rule__SequenceOperationExpression__Group__2__Impl17226 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceOperationExpression__Group__3__Impl_in_rule__SequenceOperationExpression__Group__317256 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceOperationExpression__SuffixAssignment_3_in_rule__SequenceOperationExpression__Group__3__Impl17283 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceReductionExpression__Group__0__Impl_in_rule__SequenceReductionExpression__Group__017322 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});

+    public static final BitSet FOLLOW_rule__SequenceReductionExpression__Group__1_in_rule__SequenceReductionExpression__Group__017325 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_80_in_rule__SequenceReductionExpression__Group__0__Impl17353 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceReductionExpression__Group__1__Impl_in_rule__SequenceReductionExpression__Group__117384 = new BitSet(new long[]{0x0000000000000100L,0x0002000000000000L});

+    public static final BitSet FOLLOW_rule__SequenceReductionExpression__Group__2_in_rule__SequenceReductionExpression__Group__117387 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_81_in_rule__SequenceReductionExpression__Group__1__Impl17415 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceReductionExpression__Group__2__Impl_in_rule__SequenceReductionExpression__Group__217446 = new BitSet(new long[]{0x0000000000000100L,0x0002000000000000L});

+    public static final BitSet FOLLOW_rule__SequenceReductionExpression__Group__3_in_rule__SequenceReductionExpression__Group__217449 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceReductionExpression__IsOrderedAssignment_2_in_rule__SequenceReductionExpression__Group__2__Impl17476 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceReductionExpression__Group__3__Impl_in_rule__SequenceReductionExpression__Group__317507 = new BitSet(new long[]{0x0000000000000000L,0x0000000000012000L});

+    public static final BitSet FOLLOW_rule__SequenceReductionExpression__Group__4_in_rule__SequenceReductionExpression__Group__317510 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceReductionExpression__BehaviorAssignment_3_in_rule__SequenceReductionExpression__Group__3__Impl17537 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceReductionExpression__Group__4__Impl_in_rule__SequenceReductionExpression__Group__417567 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceReductionExpression__SuffixAssignment_4_in_rule__SequenceReductionExpression__Group__4__Impl17594 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__0__Impl_in_rule__SelectOrRejectOperation__Group__017635 = new BitSet(new long[]{0x000000C000000000L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__1_in_rule__SelectOrRejectOperation__Group__017638 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_80_in_rule__SelectOrRejectOperation__Group__0__Impl17666 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__1__Impl_in_rule__SelectOrRejectOperation__Group__117697 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__2_in_rule__SelectOrRejectOperation__Group__117700 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__OpAssignment_1_in_rule__SelectOrRejectOperation__Group__1__Impl17727 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__2__Impl_in_rule__SelectOrRejectOperation__Group__217757 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__3_in_rule__SelectOrRejectOperation__Group__217760 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__NameAssignment_2_in_rule__SelectOrRejectOperation__Group__2__Impl17787 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__3__Impl_in_rule__SelectOrRejectOperation__Group__317817 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__4_in_rule__SelectOrRejectOperation__Group__317820 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__SelectOrRejectOperation__Group__3__Impl17848 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__4__Impl_in_rule__SelectOrRejectOperation__Group__417879 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__5_in_rule__SelectOrRejectOperation__Group__417882 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__ExprAssignment_4_in_rule__SelectOrRejectOperation__Group__4__Impl17909 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__5__Impl_in_rule__SelectOrRejectOperation__Group__517939 = new BitSet(new long[]{0x0000000000000000L,0x0000000000012000L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__6_in_rule__SelectOrRejectOperation__Group__517942 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__SelectOrRejectOperation__Group__5__Impl17970 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__Group__6__Impl_in_rule__SelectOrRejectOperation__Group__618001 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SelectOrRejectOperation__SuffixAssignment_6_in_rule__SelectOrRejectOperation__Group__6__Impl18028 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__0__Impl_in_rule__CollectOrIterateOperation__Group__018073 = new BitSet(new long[]{0x0000030000000000L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__1_in_rule__CollectOrIterateOperation__Group__018076 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_80_in_rule__CollectOrIterateOperation__Group__0__Impl18104 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__1__Impl_in_rule__CollectOrIterateOperation__Group__118135 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__2_in_rule__CollectOrIterateOperation__Group__118138 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__OpAssignment_1_in_rule__CollectOrIterateOperation__Group__1__Impl18165 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__2__Impl_in_rule__CollectOrIterateOperation__Group__218195 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__3_in_rule__CollectOrIterateOperation__Group__218198 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__NameAssignment_2_in_rule__CollectOrIterateOperation__Group__2__Impl18225 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__3__Impl_in_rule__CollectOrIterateOperation__Group__318255 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__4_in_rule__CollectOrIterateOperation__Group__318258 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__CollectOrIterateOperation__Group__3__Impl18286 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__4__Impl_in_rule__CollectOrIterateOperation__Group__418317 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__5_in_rule__CollectOrIterateOperation__Group__418320 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__ExprAssignment_4_in_rule__CollectOrIterateOperation__Group__4__Impl18347 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__5__Impl_in_rule__CollectOrIterateOperation__Group__518377 = new BitSet(new long[]{0x0000000000000000L,0x0000000000012000L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__6_in_rule__CollectOrIterateOperation__Group__518380 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__CollectOrIterateOperation__Group__5__Impl18408 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__Group__6__Impl_in_rule__CollectOrIterateOperation__Group__618439 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CollectOrIterateOperation__SuffixAssignment_6_in_rule__CollectOrIterateOperation__Group__6__Impl18466 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__0__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__018511 = new BitSet(new long[]{0x00001C0000000000L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__1_in_rule__ForAllOrExistsOrOneOperation__Group__018514 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_80_in_rule__ForAllOrExistsOrOneOperation__Group__0__Impl18542 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__1__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__118573 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__2_in_rule__ForAllOrExistsOrOneOperation__Group__118576 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__OpAssignment_1_in_rule__ForAllOrExistsOrOneOperation__Group__1__Impl18603 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__2__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__218633 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__3_in_rule__ForAllOrExistsOrOneOperation__Group__218636 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__NameAssignment_2_in_rule__ForAllOrExistsOrOneOperation__Group__2__Impl18663 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__3__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__318693 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__4_in_rule__ForAllOrExistsOrOneOperation__Group__318696 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__ForAllOrExistsOrOneOperation__Group__3__Impl18724 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__4__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__418755 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__5_in_rule__ForAllOrExistsOrOneOperation__Group__418758 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__ExprAssignment_4_in_rule__ForAllOrExistsOrOneOperation__Group__4__Impl18785 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__5__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__518815 = new BitSet(new long[]{0x0000000000000000L,0x0000000000012000L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__6_in_rule__ForAllOrExistsOrOneOperation__Group__518818 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__ForAllOrExistsOrOneOperation__Group__5__Impl18846 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__Group__6__Impl_in_rule__ForAllOrExistsOrOneOperation__Group__618877 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForAllOrExistsOrOneOperation__SuffixAssignment_6_in_rule__ForAllOrExistsOrOneOperation__Group__6__Impl18904 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__0__Impl_in_rule__IsUniqueOperation__Group__018949 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__1_in_rule__IsUniqueOperation__Group__018952 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_80_in_rule__IsUniqueOperation__Group__0__Impl18980 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__1__Impl_in_rule__IsUniqueOperation__Group__119011 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__2_in_rule__IsUniqueOperation__Group__119014 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_82_in_rule__IsUniqueOperation__Group__1__Impl19042 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__2__Impl_in_rule__IsUniqueOperation__Group__219073 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__3_in_rule__IsUniqueOperation__Group__219076 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__NameAssignment_2_in_rule__IsUniqueOperation__Group__2__Impl19103 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__3__Impl_in_rule__IsUniqueOperation__Group__319133 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__4_in_rule__IsUniqueOperation__Group__319136 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__IsUniqueOperation__Group__3__Impl19164 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__4__Impl_in_rule__IsUniqueOperation__Group__419195 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__5_in_rule__IsUniqueOperation__Group__419198 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__ExprAssignment_4_in_rule__IsUniqueOperation__Group__4__Impl19225 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__5__Impl_in_rule__IsUniqueOperation__Group__519255 = new BitSet(new long[]{0x0000000000000000L,0x0000000000012000L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__6_in_rule__IsUniqueOperation__Group__519258 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__IsUniqueOperation__Group__5__Impl19286 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__Group__6__Impl_in_rule__IsUniqueOperation__Group__619317 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IsUniqueOperation__SuffixAssignment_6_in_rule__IsUniqueOperation__Group__6__Impl19344 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ParenthesizedExpression__Group__0__Impl_in_rule__ParenthesizedExpression__Group__019389 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__ParenthesizedExpression__Group__1_in_rule__ParenthesizedExpression__Group__019392 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__ParenthesizedExpression__Group__0__Impl19420 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ParenthesizedExpression__Group__1__Impl_in_rule__ParenthesizedExpression__Group__119451 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__ParenthesizedExpression__Group__2_in_rule__ParenthesizedExpression__Group__119454 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ParenthesizedExpression__ExpOrTypeCastAssignment_1_in_rule__ParenthesizedExpression__Group__1__Impl19481 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ParenthesizedExpression__Group__2__Impl_in_rule__ParenthesizedExpression__Group__219511 = new BitSet(new long[]{0x0000000000003130L,0x00007B93C8F12010L});

+    public static final BitSet FOLLOW_rule__ParenthesizedExpression__Group__3_in_rule__ParenthesizedExpression__Group__219514 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__ParenthesizedExpression__Group__2__Impl19542 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ParenthesizedExpression__Group__3__Impl_in_rule__ParenthesizedExpression__Group__319573 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ParenthesizedExpression__Alternatives_3_in_rule__ParenthesizedExpression__Group__3__Impl19600 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NullExpression__Group__0__Impl_in_rule__NullExpression__Group__019639 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__NullExpression__Group__1_in_rule__NullExpression__Group__019642 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NullExpression__Group__1__Impl_in_rule__NullExpression__Group__119700 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_83_in_rule__NullExpression__Group__1__Impl19728 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ThisExpression__Group__0__Impl_in_rule__ThisExpression__Group__019763 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});

+    public static final BitSet FOLLOW_rule__ThisExpression__Group__1_in_rule__ThisExpression__Group__019766 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ThisExpression__Group__1__Impl_in_rule__ThisExpression__Group__119824 = new BitSet(new long[]{0x0000000000000000L,0x0000000000012000L});

+    public static final BitSet FOLLOW_rule__ThisExpression__Group__2_in_rule__ThisExpression__Group__119827 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_84_in_rule__ThisExpression__Group__1__Impl19855 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ThisExpression__Group__2__Impl_in_rule__ThisExpression__Group__219886 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ThisExpression__SuffixAssignment_2_in_rule__ThisExpression__Group__2__Impl19913 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__Group__0__Impl_in_rule__SuperInvocationExpression__Group__019950 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002010L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__Group__1_in_rule__SuperInvocationExpression__Group__019953 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_85_in_rule__SuperInvocationExpression__Group__0__Impl19981 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__Group__1__Impl_in_rule__SuperInvocationExpression__Group__120012 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__Alternatives_1_in_rule__SuperInvocationExpression__Group__1__Impl20039 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__Group_1_1__0__Impl_in_rule__SuperInvocationExpression__Group_1_1__020073 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__Group_1_1__1_in_rule__SuperInvocationExpression__Group_1_1__020076 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_77_in_rule__SuperInvocationExpression__Group_1_1__0__Impl20104 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__Group_1_1__1__Impl_in_rule__SuperInvocationExpression__Group_1_1__120135 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__Group_1_1__2_in_rule__SuperInvocationExpression__Group_1_1__120138 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__OperationNameAssignment_1_1_1_in_rule__SuperInvocationExpression__Group_1_1__1__Impl20165 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__Group_1_1__2__Impl_in_rule__SuperInvocationExpression__Group_1_1__220195 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationExpression__TupleAssignment_1_1_2_in_rule__SuperInvocationExpression__Group_1_1__2__Impl20222 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationExpression__Group__0__Impl_in_rule__InstanceCreationExpression__Group__020258 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__InstanceCreationExpression__Group__1_in_rule__InstanceCreationExpression__Group__020261 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_86_in_rule__InstanceCreationExpression__Group__0__Impl20289 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationExpression__Group__1__Impl_in_rule__InstanceCreationExpression__Group__120320 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__InstanceCreationExpression__Group__2_in_rule__InstanceCreationExpression__Group__120323 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationExpression__ConstructorAssignment_1_in_rule__InstanceCreationExpression__Group__1__Impl20350 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationExpression__Group__2__Impl_in_rule__InstanceCreationExpression__Group__220380 = new BitSet(new long[]{0x0000000000000000L,0x0000000000012000L});

+    public static final BitSet FOLLOW_rule__InstanceCreationExpression__Group__3_in_rule__InstanceCreationExpression__Group__220383 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationExpression__TupleAssignment_2_in_rule__InstanceCreationExpression__Group__2__Impl20410 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationExpression__Group__3__Impl_in_rule__InstanceCreationExpression__Group__320440 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationExpression__SuffixAssignment_3_in_rule__InstanceCreationExpression__Group__3__Impl20467 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group__0__Impl_in_rule__InstanceCreationTuple__Group__020506 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group__1_in_rule__InstanceCreationTuple__Group__020509 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group__1__Impl_in_rule__InstanceCreationTuple__Group__120567 = new BitSet(new long[]{0x0000000000000100L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group__2_in_rule__InstanceCreationTuple__Group__120570 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__InstanceCreationTuple__Group__1__Impl20598 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group__2__Impl_in_rule__InstanceCreationTuple__Group__220629 = new BitSet(new long[]{0x0000000000000100L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group__3_in_rule__InstanceCreationTuple__Group__220632 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group_2__0_in_rule__InstanceCreationTuple__Group__2__Impl20659 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group__3__Impl_in_rule__InstanceCreationTuple__Group__320690 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__InstanceCreationTuple__Group__3__Impl20718 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group_2__0__Impl_in_rule__InstanceCreationTuple__Group_2__020757 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group_2__1_in_rule__InstanceCreationTuple__Group_2__020760 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_0_in_rule__InstanceCreationTuple__Group_2__0__Impl20787 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group_2__1__Impl_in_rule__InstanceCreationTuple__Group_2__120817 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group_2_1__0_in_rule__InstanceCreationTuple__Group_2__1__Impl20844 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group_2_1__0__Impl_in_rule__InstanceCreationTuple__Group_2_1__020879 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group_2_1__1_in_rule__InstanceCreationTuple__Group_2_1__020882 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_66_in_rule__InstanceCreationTuple__Group_2_1__0__Impl20910 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__Group_2_1__1__Impl_in_rule__InstanceCreationTuple__Group_2_1__120941 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_1_in_rule__InstanceCreationTuple__Group_2_1__1__Impl20968 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTupleElement__Group__0__Impl_in_rule__InstanceCreationTupleElement__Group__021002 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTupleElement__Group__1_in_rule__InstanceCreationTupleElement__Group__021005 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTupleElement__RoleAssignment_0_in_rule__InstanceCreationTupleElement__Group__0__Impl21032 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTupleElement__Group__1__Impl_in_rule__InstanceCreationTupleElement__Group__121062 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTupleElement__Group__2_in_rule__InstanceCreationTupleElement__Group__121065 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_67_in_rule__InstanceCreationTupleElement__Group__1__Impl21093 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTupleElement__Group__2__Impl_in_rule__InstanceCreationTupleElement__Group__221124 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationTupleElement__ObjectAssignment_2_in_rule__InstanceCreationTupleElement__Group__2__Impl21151 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl_in_rule__SequenceConstructionOrAccessCompletion__Group_0__021187 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F88010L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionOrAccessCompletion__Group_0__1_in_rule__SequenceConstructionOrAccessCompletion__Group_0__021190 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_0_in_rule__SequenceConstructionOrAccessCompletion__Group_0__0__Impl21217 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl_in_rule__SequenceConstructionOrAccessCompletion__Group_0__121247 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionOrAccessCompletion__Alternatives_0_1_in_rule__SequenceConstructionOrAccessCompletion__Group_0__1__Impl21274 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AccessCompletion__Group__0__Impl_in_rule__AccessCompletion__Group__021308 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});

+    public static final BitSet FOLLOW_rule__AccessCompletion__Group__1_in_rule__AccessCompletion__Group__021311 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AccessCompletion__AccessIndexAssignment_0_in_rule__AccessCompletion__Group__0__Impl21338 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AccessCompletion__Group__1__Impl_in_rule__AccessCompletion__Group__121368 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_79_in_rule__AccessCompletion__Group__1__Impl21396 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PartialSequenceConstructionCompletion__Group__0__Impl_in_rule__PartialSequenceConstructionCompletion__Group__021431 = new BitSet(new long[]{0x0000000000000000L,0x0000000000804000L});

+    public static final BitSet FOLLOW_rule__PartialSequenceConstructionCompletion__Group__1_in_rule__PartialSequenceConstructionCompletion__Group__021434 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_79_in_rule__PartialSequenceConstructionCompletion__Group__0__Impl21462 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PartialSequenceConstructionCompletion__Group__1__Impl_in_rule__PartialSequenceConstructionCompletion__Group__121493 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__PartialSequenceConstructionCompletion__ExpressionAssignment_1_in_rule__PartialSequenceConstructionCompletion__Group__1__Impl21520 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group__0__Impl_in_rule__SequenceConstructionExpression__Group__021554 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F84010L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group__1_in_rule__SequenceConstructionExpression__Group__021557 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_87_in_rule__SequenceConstructionExpression__Group__0__Impl21585 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group__1__Impl_in_rule__SequenceConstructionExpression__Group__121616 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000004L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group__2_in_rule__SequenceConstructionExpression__Group__121619 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__SequenceElementAssignment_1_in_rule__SequenceConstructionExpression__Group__1__Impl21646 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group__2__Impl_in_rule__SequenceConstructionExpression__Group__221676 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group__3_in_rule__SequenceConstructionExpression__Group__221679 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Alternatives_2_in_rule__SequenceConstructionExpression__Group__2__Impl21706 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group__3__Impl_in_rule__SequenceConstructionExpression__Group__321736 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_88_in_rule__SequenceConstructionExpression__Group__3__Impl21764 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group_2_0__0__Impl_in_rule__SequenceConstructionExpression__Group_2_0__021803 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F84010L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group_2_0__1_in_rule__SequenceConstructionExpression__Group_2_0__021806 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_66_in_rule__SequenceConstructionExpression__Group_2_0__0__Impl21834 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group_2_0__1__Impl_in_rule__SequenceConstructionExpression__Group_2_0__121865 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_1_in_rule__SequenceConstructionExpression__Group_2_0__1__Impl21892 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group_2_1__0__Impl_in_rule__SequenceConstructionExpression__Group_2_1__021926 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group_2_1__1_in_rule__SequenceConstructionExpression__Group_2_1__021929 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_89_in_rule__SequenceConstructionExpression__Group_2_1__0__Impl21957 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__Group_2_1__1__Impl_in_rule__SequenceConstructionExpression__Group_2_1__121988 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_1_in_rule__SequenceConstructionExpression__Group_2_1__1__Impl22015 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassExtentExpression__Group__0__Impl_in_rule__ClassExtentExpression__Group__022049 = new BitSet(new long[]{0x0000000000000000L,0x0000000000012000L});

+    public static final BitSet FOLLOW_rule__ClassExtentExpression__Group__1_in_rule__ClassExtentExpression__Group__022052 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassExtentExpression__Group__1__Impl_in_rule__ClassExtentExpression__Group__122110 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L});

+    public static final BitSet FOLLOW_rule__ClassExtentExpression__Group__2_in_rule__ClassExtentExpression__Group__122113 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_77_in_rule__ClassExtentExpression__Group__1__Impl22141 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassExtentExpression__Group__2__Impl_in_rule__ClassExtentExpression__Group__222172 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__ClassExtentExpression__Group__3_in_rule__ClassExtentExpression__Group__222175 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_90_in_rule__ClassExtentExpression__Group__2__Impl22203 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassExtentExpression__Group__3__Impl_in_rule__ClassExtentExpression__Group__322234 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__ClassExtentExpression__Group__4_in_rule__ClassExtentExpression__Group__322237 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__ClassExtentExpression__Group__3__Impl22265 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassExtentExpression__Group__4__Impl_in_rule__ClassExtentExpression__Group__422296 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__ClassExtentExpression__Group__4__Impl22324 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Block__Group__0__Impl_in_rule__Block__Group__022365 = new BitSet(new long[]{0x0000000000003130L,0x00007B93C9F00000L});

+    public static final BitSet FOLLOW_rule__Block__Group__1_in_rule__Block__Group__022368 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_87_in_rule__Block__Group__0__Impl22396 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Block__Group__1__Impl_in_rule__Block__Group__122427 = new BitSet(new long[]{0x0000000000003130L,0x00007B93C9F00000L});

+    public static final BitSet FOLLOW_rule__Block__Group__2_in_rule__Block__Group__122430 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Block__Group__2__Impl_in_rule__Block__Group__222488 = new BitSet(new long[]{0x0000000000003130L,0x00007B93C9F00000L});

+    public static final BitSet FOLLOW_rule__Block__Group__3_in_rule__Block__Group__222491 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Block__SequenceAssignment_2_in_rule__Block__Group__2__Impl22518 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Block__Group__3__Impl_in_rule__Block__Group__322549 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_88_in_rule__Block__Group__3__Impl22577 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DocumentedStatement__Group__0__Impl_in_rule__DocumentedStatement__Group__022616 = new BitSet(new long[]{0x0000000000003130L,0x00007B93C8F00000L});

+    public static final BitSet FOLLOW_rule__DocumentedStatement__Group__1_in_rule__DocumentedStatement__Group__022619 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DocumentedStatement__CommentAssignment_0_in_rule__DocumentedStatement__Group__0__Impl22646 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DocumentedStatement__Group__1__Impl_in_rule__DocumentedStatement__Group__122677 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DocumentedStatement__StatementAssignment_1_in_rule__DocumentedStatement__Group__1__Impl22704 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__0__Impl_in_rule__InlineStatement__Group__022738 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__1_in_rule__InlineStatement__Group__022741 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_91_in_rule__InlineStatement__Group__0__Impl22769 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__1__Impl_in_rule__InlineStatement__Group__122800 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__2_in_rule__InlineStatement__Group__122803 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_92_in_rule__InlineStatement__Group__1__Impl22831 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__2__Impl_in_rule__InlineStatement__Group__222862 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__3_in_rule__InlineStatement__Group__222865 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__InlineStatement__Group__2__Impl22893 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__3__Impl_in_rule__InlineStatement__Group__322924 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__4_in_rule__InlineStatement__Group__322927 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InlineStatement__LangageNameAssignment_3_in_rule__InlineStatement__Group__3__Impl22954 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__4__Impl_in_rule__InlineStatement__Group__422984 = new BitSet(new long[]{0x0000000000000080L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__5_in_rule__InlineStatement__Group__422987 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__InlineStatement__Group__4__Impl23015 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__5__Impl_in_rule__InlineStatement__Group__523046 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__6_in_rule__InlineStatement__Group__523049 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InlineStatement__BodyAssignment_5_in_rule__InlineStatement__Group__5__Impl23076 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InlineStatement__Group__6__Impl_in_rule__InlineStatement__Group__623106 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_93_in_rule__InlineStatement__Group__6__Impl23134 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AnnotatedStatement__Group__0__Impl_in_rule__AnnotatedStatement__Group__023179 = new BitSet(new long[]{0x0001E00000000000L});

+    public static final BitSet FOLLOW_rule__AnnotatedStatement__Group__1_in_rule__AnnotatedStatement__Group__023182 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_94_in_rule__AnnotatedStatement__Group__0__Impl23210 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AnnotatedStatement__Group__1__Impl_in_rule__AnnotatedStatement__Group__123241 = new BitSet(new long[]{0x0000000000003130L,0x00007B93C8F00000L});

+    public static final BitSet FOLLOW_rule__AnnotatedStatement__Group__2_in_rule__AnnotatedStatement__Group__123244 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AnnotatedStatement__AnnotationAssignment_1_in_rule__AnnotatedStatement__Group__1__Impl23271 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AnnotatedStatement__Group__2__Impl_in_rule__AnnotatedStatement__Group__223301 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AnnotatedStatement__StatementAssignment_2_in_rule__AnnotatedStatement__Group__2__Impl23328 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Annotation__Group__0__Impl_in_rule__Annotation__Group__023364 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__Annotation__Group__1_in_rule__Annotation__Group__023367 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Annotation__KindAssignment_0_in_rule__Annotation__Group__0__Impl23394 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Annotation__Group__1__Impl_in_rule__Annotation__Group__123424 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Annotation__Group_1__0_in_rule__Annotation__Group__1__Impl23451 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Annotation__Group_1__0__Impl_in_rule__Annotation__Group_1__023486 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__Annotation__Group_1__1_in_rule__Annotation__Group_1__023489 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__Annotation__Group_1__0__Impl23517 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Annotation__Group_1__1__Impl_in_rule__Annotation__Group_1__123548 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000024L});

+    public static final BitSet FOLLOW_rule__Annotation__Group_1__2_in_rule__Annotation__Group_1__123551 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Annotation__ArgsAssignment_1_1_in_rule__Annotation__Group_1__1__Impl23578 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Annotation__Group_1__2__Impl_in_rule__Annotation__Group_1__223608 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000024L});

+    public static final BitSet FOLLOW_rule__Annotation__Group_1__3_in_rule__Annotation__Group_1__223611 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Annotation__Group_1_2__0_in_rule__Annotation__Group_1__2__Impl23638 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__Annotation__Group_1__3__Impl_in_rule__Annotation__Group_1__323669 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__Annotation__Group_1__3__Impl23697 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Annotation__Group_1_2__0__Impl_in_rule__Annotation__Group_1_2__023736 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__Annotation__Group_1_2__1_in_rule__Annotation__Group_1_2__023739 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_66_in_rule__Annotation__Group_1_2__0__Impl23767 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Annotation__Group_1_2__1__Impl_in_rule__Annotation__Group_1_2__123798 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__Annotation__ArgsAssignment_1_2_1_in_rule__Annotation__Group_1_2__1__Impl23825 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__EmptyStatement__Group__0__Impl_in_rule__EmptyStatement__Group__023859 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L});

+    public static final BitSet FOLLOW_rule__EmptyStatement__Group__1_in_rule__EmptyStatement__Group__023862 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__EmptyStatement__Group__1__Impl_in_rule__EmptyStatement__Group__123920 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_95_in_rule__EmptyStatement__Group__1__Impl23948 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__0__Impl_in_rule__LocalNameDeclarationStatement__Group__023983 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__1_in_rule__LocalNameDeclarationStatement__Group__023986 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_96_in_rule__LocalNameDeclarationStatement__Group__0__Impl24014 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__1__Impl_in_rule__LocalNameDeclarationStatement__Group__124045 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__2_in_rule__LocalNameDeclarationStatement__Group__124048 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__VarNameAssignment_1_in_rule__LocalNameDeclarationStatement__Group__1__Impl24075 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__2__Impl_in_rule__LocalNameDeclarationStatement__Group__224105 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__3_in_rule__LocalNameDeclarationStatement__Group__224108 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_71_in_rule__LocalNameDeclarationStatement__Group__2__Impl24136 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__3__Impl_in_rule__LocalNameDeclarationStatement__Group__324167 = new BitSet(new long[]{0x0002000000000000L,0x0000000000004000L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__4_in_rule__LocalNameDeclarationStatement__Group__324170 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__TypeAssignment_3_in_rule__LocalNameDeclarationStatement__Group__3__Impl24197 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__4__Impl_in_rule__LocalNameDeclarationStatement__Group__424227 = new BitSet(new long[]{0x0002000000000000L,0x0000000000004000L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__5_in_rule__LocalNameDeclarationStatement__Group__424230 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group_4__0_in_rule__LocalNameDeclarationStatement__Group__4__Impl24257 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__5__Impl_in_rule__LocalNameDeclarationStatement__Group__524288 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F84010L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__6_in_rule__LocalNameDeclarationStatement__Group__524291 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_49_in_rule__LocalNameDeclarationStatement__Group__5__Impl24319 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__6__Impl_in_rule__LocalNameDeclarationStatement__Group__624350 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__7_in_rule__LocalNameDeclarationStatement__Group__624353 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__InitAssignment_6_in_rule__LocalNameDeclarationStatement__Group__6__Impl24380 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group__7__Impl_in_rule__LocalNameDeclarationStatement__Group__724410 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_95_in_rule__LocalNameDeclarationStatement__Group__7__Impl24438 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group_4__0__Impl_in_rule__LocalNameDeclarationStatement__Group_4__024485 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group_4__1_in_rule__LocalNameDeclarationStatement__Group_4__024488 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_0_in_rule__LocalNameDeclarationStatement__Group_4__0__Impl24515 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LocalNameDeclarationStatement__Group_4__1__Impl_in_rule__LocalNameDeclarationStatement__Group_4__124545 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_79_in_rule__LocalNameDeclarationStatement__Group_4__1__Impl24573 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IfStatement__Group__0__Impl_in_rule__IfStatement__Group__024608 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__IfStatement__Group__1_in_rule__IfStatement__Group__024611 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_97_in_rule__IfStatement__Group__0__Impl24639 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IfStatement__Group__1__Impl_in_rule__IfStatement__Group__124670 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L});

+    public static final BitSet FOLLOW_rule__IfStatement__Group__2_in_rule__IfStatement__Group__124673 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IfStatement__SequentialClaussesAssignment_1_in_rule__IfStatement__Group__1__Impl24700 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IfStatement__Group__2__Impl_in_rule__IfStatement__Group__224730 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__IfStatement__FinalClauseAssignment_2_in_rule__IfStatement__Group__2__Impl24757 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequentialClauses__Group__0__Impl_in_rule__SequentialClauses__Group__024794 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L});

+    public static final BitSet FOLLOW_rule__SequentialClauses__Group__1_in_rule__SequentialClauses__Group__024797 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequentialClauses__ConccurentClausesAssignment_0_in_rule__SequentialClauses__Group__0__Impl24824 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequentialClauses__Group__1__Impl_in_rule__SequentialClauses__Group__124854 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequentialClauses__Group_1__0_in_rule__SequentialClauses__Group__1__Impl24881 = new BitSet(new long[]{0x0000000000000002L,0x0000000400000000L});

+    public static final BitSet FOLLOW_rule__SequentialClauses__Group_1__0__Impl_in_rule__SequentialClauses__Group_1__024916 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});

+    public static final BitSet FOLLOW_rule__SequentialClauses__Group_1__1_in_rule__SequentialClauses__Group_1__024919 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_98_in_rule__SequentialClauses__Group_1__0__Impl24947 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequentialClauses__Group_1__1__Impl_in_rule__SequentialClauses__Group_1__124978 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__SequentialClauses__Group_1__2_in_rule__SequentialClauses__Group_1__124981 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_97_in_rule__SequentialClauses__Group_1__1__Impl25009 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequentialClauses__Group_1__2__Impl_in_rule__SequentialClauses__Group_1__225040 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SequentialClauses__ConccurentClausesAssignment_1_2_in_rule__SequentialClauses__Group_1__2__Impl25067 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConcurrentClauses__Group__0__Impl_in_rule__ConcurrentClauses__Group__025103 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});

+    public static final BitSet FOLLOW_rule__ConcurrentClauses__Group__1_in_rule__ConcurrentClauses__Group__025106 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConcurrentClauses__NonFinalClauseAssignment_0_in_rule__ConcurrentClauses__Group__0__Impl25133 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConcurrentClauses__Group__1__Impl_in_rule__ConcurrentClauses__Group__125163 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConcurrentClauses__Group_1__0_in_rule__ConcurrentClauses__Group__1__Impl25190 = new BitSet(new long[]{0x0000000000000002L,0x0000000800000000L});

+    public static final BitSet FOLLOW_rule__ConcurrentClauses__Group_1__0__Impl_in_rule__ConcurrentClauses__Group_1__025225 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});

+    public static final BitSet FOLLOW_rule__ConcurrentClauses__Group_1__1_in_rule__ConcurrentClauses__Group_1__025228 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_99_in_rule__ConcurrentClauses__Group_1__0__Impl25256 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConcurrentClauses__Group_1__1__Impl_in_rule__ConcurrentClauses__Group_1__125287 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__ConcurrentClauses__Group_1__2_in_rule__ConcurrentClauses__Group_1__125290 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_97_in_rule__ConcurrentClauses__Group_1__1__Impl25318 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConcurrentClauses__Group_1__2__Impl_in_rule__ConcurrentClauses__Group_1__225349 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ConcurrentClauses__NonFinalClauseAssignment_1_2_in_rule__ConcurrentClauses__Group_1__2__Impl25376 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NonFinalClause__Group__0__Impl_in_rule__NonFinalClause__Group__025412 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__NonFinalClause__Group__1_in_rule__NonFinalClause__Group__025415 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__NonFinalClause__Group__0__Impl25443 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NonFinalClause__Group__1__Impl_in_rule__NonFinalClause__Group__125474 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__NonFinalClause__Group__2_in_rule__NonFinalClause__Group__125477 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NonFinalClause__ConditionAssignment_1_in_rule__NonFinalClause__Group__1__Impl25504 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NonFinalClause__Group__2__Impl_in_rule__NonFinalClause__Group__225534 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});

+    public static final BitSet FOLLOW_rule__NonFinalClause__Group__3_in_rule__NonFinalClause__Group__225537 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__NonFinalClause__Group__2__Impl25565 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NonFinalClause__Group__3__Impl_in_rule__NonFinalClause__Group__325596 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NonFinalClause__BlockAssignment_3_in_rule__NonFinalClause__Group__3__Impl25623 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__FinalClause__Group__0__Impl_in_rule__FinalClause__Group__025661 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});

+    public static final BitSet FOLLOW_rule__FinalClause__Group__1_in_rule__FinalClause__Group__025664 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_98_in_rule__FinalClause__Group__0__Impl25692 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__FinalClause__Group__1__Impl_in_rule__FinalClause__Group__125723 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__FinalClause__BlockAssignment_1_in_rule__FinalClause__Group__1__Impl25750 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__0__Impl_in_rule__SwitchStatement__Group__025784 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__1_in_rule__SwitchStatement__Group__025787 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_100_in_rule__SwitchStatement__Group__0__Impl25815 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__1__Impl_in_rule__SwitchStatement__Group__125846 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__2_in_rule__SwitchStatement__Group__125849 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__SwitchStatement__Group__1__Impl25877 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__2__Impl_in_rule__SwitchStatement__Group__225908 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__3_in_rule__SwitchStatement__Group__225911 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__ExpressionAssignment_2_in_rule__SwitchStatement__Group__2__Impl25938 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__3__Impl_in_rule__SwitchStatement__Group__325968 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__4_in_rule__SwitchStatement__Group__325971 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__SwitchStatement__Group__3__Impl25999 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__4__Impl_in_rule__SwitchStatement__Group__426030 = new BitSet(new long[]{0x0000000000000000L,0x0000006001000000L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__5_in_rule__SwitchStatement__Group__426033 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_87_in_rule__SwitchStatement__Group__4__Impl26061 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__5__Impl_in_rule__SwitchStatement__Group__526092 = new BitSet(new long[]{0x0000000000000000L,0x0000006001000000L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__6_in_rule__SwitchStatement__Group__526095 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__SwitchClauseAssignment_5_in_rule__SwitchStatement__Group__5__Impl26122 = new BitSet(new long[]{0x0000000000000002L,0x0000002000000000L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__6__Impl_in_rule__SwitchStatement__Group__626153 = new BitSet(new long[]{0x0000000000000000L,0x0000006001000000L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__7_in_rule__SwitchStatement__Group__626156 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__DefaultClauseAssignment_6_in_rule__SwitchStatement__Group__6__Impl26183 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchStatement__Group__7__Impl_in_rule__SwitchStatement__Group__726214 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_88_in_rule__SwitchStatement__Group__7__Impl26242 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchClause__Group__0__Impl_in_rule__SwitchClause__Group__026289 = new BitSet(new long[]{0x0000000000003130L,0x00007BB3C8F00000L});

+    public static final BitSet FOLLOW_rule__SwitchClause__Group__1_in_rule__SwitchClause__Group__026292 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchClause__SwitchCaseAssignment_0_in_rule__SwitchClause__Group__0__Impl26319 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchClause__Group__1__Impl_in_rule__SwitchClause__Group__126349 = new BitSet(new long[]{0x0000000000003130L,0x00007BB3C8F00000L});

+    public static final BitSet FOLLOW_rule__SwitchClause__Group__2_in_rule__SwitchClause__Group__126352 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchClause__SwitchCaseAssignment_1_in_rule__SwitchClause__Group__1__Impl26379 = new BitSet(new long[]{0x0000000000000002L,0x0000002000000000L});

+    public static final BitSet FOLLOW_rule__SwitchClause__Group__2__Impl_in_rule__SwitchClause__Group__226410 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchClause__StatementSequenceAssignment_2_in_rule__SwitchClause__Group__2__Impl26437 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchCase__Group__0__Impl_in_rule__SwitchCase__Group__026473 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__SwitchCase__Group__1_in_rule__SwitchCase__Group__026476 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_101_in_rule__SwitchCase__Group__0__Impl26504 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchCase__Group__1__Impl_in_rule__SwitchCase__Group__126535 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});

+    public static final BitSet FOLLOW_rule__SwitchCase__Group__2_in_rule__SwitchCase__Group__126538 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchCase__ExpressionAssignment_1_in_rule__SwitchCase__Group__1__Impl26565 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchCase__Group__2__Impl_in_rule__SwitchCase__Group__226595 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_71_in_rule__SwitchCase__Group__2__Impl26623 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchDefaultClause__Group__0__Impl_in_rule__SwitchDefaultClause__Group__026660 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});

+    public static final BitSet FOLLOW_rule__SwitchDefaultClause__Group__1_in_rule__SwitchDefaultClause__Group__026663 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_102_in_rule__SwitchDefaultClause__Group__0__Impl26691 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchDefaultClause__Group__1__Impl_in_rule__SwitchDefaultClause__Group__126722 = new BitSet(new long[]{0x0000000000003130L,0x00007BB3C8F00000L});

+    public static final BitSet FOLLOW_rule__SwitchDefaultClause__Group__2_in_rule__SwitchDefaultClause__Group__126725 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_71_in_rule__SwitchDefaultClause__Group__1__Impl26753 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchDefaultClause__Group__2__Impl_in_rule__SwitchDefaultClause__Group__226784 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SwitchDefaultClause__StatementSequenceAssignment_2_in_rule__SwitchDefaultClause__Group__2__Impl26811 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__WhileStatement__Group__0__Impl_in_rule__WhileStatement__Group__026847 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__WhileStatement__Group__1_in_rule__WhileStatement__Group__026850 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_103_in_rule__WhileStatement__Group__0__Impl26878 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__WhileStatement__Group__1__Impl_in_rule__WhileStatement__Group__126909 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__WhileStatement__Group__2_in_rule__WhileStatement__Group__126912 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__WhileStatement__Group__1__Impl26940 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__WhileStatement__Group__2__Impl_in_rule__WhileStatement__Group__226971 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__WhileStatement__Group__3_in_rule__WhileStatement__Group__226974 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__WhileStatement__ConditionAssignment_2_in_rule__WhileStatement__Group__2__Impl27001 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__WhileStatement__Group__3__Impl_in_rule__WhileStatement__Group__327031 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});

+    public static final BitSet FOLLOW_rule__WhileStatement__Group__4_in_rule__WhileStatement__Group__327034 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__WhileStatement__Group__3__Impl27062 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__WhileStatement__Group__4__Impl_in_rule__WhileStatement__Group__427093 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__WhileStatement__BlockAssignment_4_in_rule__WhileStatement__Group__4__Impl27120 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__0__Impl_in_rule__DoStatement__Group__027160 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__1_in_rule__DoStatement__Group__027163 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_104_in_rule__DoStatement__Group__0__Impl27191 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__1__Impl_in_rule__DoStatement__Group__127222 = new BitSet(new long[]{0x0000000000000000L,0x0000008000000000L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__2_in_rule__DoStatement__Group__127225 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DoStatement__BlockAssignment_1_in_rule__DoStatement__Group__1__Impl27252 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__2__Impl_in_rule__DoStatement__Group__227282 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__3_in_rule__DoStatement__Group__227285 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_103_in_rule__DoStatement__Group__2__Impl27313 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__3__Impl_in_rule__DoStatement__Group__327344 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__4_in_rule__DoStatement__Group__327347 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__DoStatement__Group__3__Impl27375 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__4__Impl_in_rule__DoStatement__Group__427406 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__5_in_rule__DoStatement__Group__427409 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DoStatement__ConditionAssignment_4_in_rule__DoStatement__Group__4__Impl27436 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__5__Impl_in_rule__DoStatement__Group__527466 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__6_in_rule__DoStatement__Group__527469 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__DoStatement__Group__5__Impl27497 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DoStatement__Group__6__Impl_in_rule__DoStatement__Group__627528 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_95_in_rule__DoStatement__Group__6__Impl27556 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForStatement__Group__0__Impl_in_rule__ForStatement__Group__027601 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__ForStatement__Group__1_in_rule__ForStatement__Group__027604 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_105_in_rule__ForStatement__Group__0__Impl27632 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForStatement__Group__1__Impl_in_rule__ForStatement__Group__127663 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__ForStatement__Group__2_in_rule__ForStatement__Group__127666 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__ForStatement__Group__1__Impl27694 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForStatement__Group__2__Impl_in_rule__ForStatement__Group__227725 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__ForStatement__Group__3_in_rule__ForStatement__Group__227728 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForStatement__ControlAssignment_2_in_rule__ForStatement__Group__2__Impl27755 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForStatement__Group__3__Impl_in_rule__ForStatement__Group__327785 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});

+    public static final BitSet FOLLOW_rule__ForStatement__Group__4_in_rule__ForStatement__Group__327788 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__ForStatement__Group__3__Impl27816 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForStatement__Group__4__Impl_in_rule__ForStatement__Group__427847 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForStatement__BlockAssignment_4_in_rule__ForStatement__Group__4__Impl27874 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForControl__Group__0__Impl_in_rule__ForControl__Group__027914 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__ForControl__Group__1_in_rule__ForControl__Group__027917 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForControl__LoopVariableDefinitionAssignment_0_in_rule__ForControl__Group__0__Impl27944 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForControl__Group__1__Impl_in_rule__ForControl__Group__127974 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForControl__Group_1__0_in_rule__ForControl__Group__1__Impl28001 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__ForControl__Group_1__0__Impl_in_rule__ForControl__Group_1__028036 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__ForControl__Group_1__1_in_rule__ForControl__Group_1__028039 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_66_in_rule__ForControl__Group_1__0__Impl28067 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForControl__Group_1__1__Impl_in_rule__ForControl__Group_1__128098 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ForControl__LoopVariableDefinitionAssignment_1_1_in_rule__ForControl__Group_1__1__Impl28125 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_0__0__Impl_in_rule__LoopVariableDefinition__Group_0__028159 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_0__1_in_rule__LoopVariableDefinition__Group_0__028162 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__NameAssignment_0_0_in_rule__LoopVariableDefinition__Group_0__0__Impl28189 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_0__1__Impl_in_rule__LoopVariableDefinition__Group_0__128219 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_0__2_in_rule__LoopVariableDefinition__Group_0__128222 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_106_in_rule__LoopVariableDefinition__Group_0__1__Impl28250 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_0__2__Impl_in_rule__LoopVariableDefinition__Group_0__228281 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_0__3_in_rule__LoopVariableDefinition__Group_0__228284 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Expression1Assignment_0_2_in_rule__LoopVariableDefinition__Group_0__2__Impl28311 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_0__3__Impl_in_rule__LoopVariableDefinition__Group_0__328341 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_0_3__0_in_rule__LoopVariableDefinition__Group_0__3__Impl28368 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_0_3__0__Impl_in_rule__LoopVariableDefinition__Group_0_3__028407 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_0_3__1_in_rule__LoopVariableDefinition__Group_0_3__028410 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_89_in_rule__LoopVariableDefinition__Group_0_3__0__Impl28438 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_0_3__1__Impl_in_rule__LoopVariableDefinition__Group_0_3__128469 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Expression2Assignment_0_3_1_in_rule__LoopVariableDefinition__Group_0_3__1__Impl28496 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_1__0__Impl_in_rule__LoopVariableDefinition__Group_1__028530 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_1__1_in_rule__LoopVariableDefinition__Group_1__028533 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__TypeAssignment_1_0_in_rule__LoopVariableDefinition__Group_1__0__Impl28560 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_1__1__Impl_in_rule__LoopVariableDefinition__Group_1__128590 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_1__2_in_rule__LoopVariableDefinition__Group_1__128593 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__NameAssignment_1_1_in_rule__LoopVariableDefinition__Group_1__1__Impl28620 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_1__2__Impl_in_rule__LoopVariableDefinition__Group_1__228650 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_1__3_in_rule__LoopVariableDefinition__Group_1__228653 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_71_in_rule__LoopVariableDefinition__Group_1__2__Impl28681 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__Group_1__3__Impl_in_rule__LoopVariableDefinition__Group_1__328712 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__LoopVariableDefinition__ExpressionAssignment_1_3_in_rule__LoopVariableDefinition__Group_1__3__Impl28739 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__BreakStatement__Group__0__Impl_in_rule__BreakStatement__Group__028777 = new BitSet(new long[]{0x0000000000000000L,0x0000080000000000L});

+    public static final BitSet FOLLOW_rule__BreakStatement__Group__1_in_rule__BreakStatement__Group__028780 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__BreakStatement__Group__1__Impl_in_rule__BreakStatement__Group__128838 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L});

+    public static final BitSet FOLLOW_rule__BreakStatement__Group__2_in_rule__BreakStatement__Group__128841 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_107_in_rule__BreakStatement__Group__1__Impl28869 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__BreakStatement__Group__2__Impl_in_rule__BreakStatement__Group__228900 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_95_in_rule__BreakStatement__Group__2__Impl28928 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ReturnStatement__Group__0__Impl_in_rule__ReturnStatement__Group__028965 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__ReturnStatement__Group__1_in_rule__ReturnStatement__Group__028968 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_108_in_rule__ReturnStatement__Group__0__Impl28996 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ReturnStatement__Group__1__Impl_in_rule__ReturnStatement__Group__129027 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L});

+    public static final BitSet FOLLOW_rule__ReturnStatement__Group__2_in_rule__ReturnStatement__Group__129030 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ReturnStatement__ExpressionAssignment_1_in_rule__ReturnStatement__Group__1__Impl29057 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ReturnStatement__Group__2__Impl_in_rule__ReturnStatement__Group__229087 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_95_in_rule__ReturnStatement__Group__2__Impl29115 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptStatement__Group__0__Impl_in_rule__AcceptStatement__Group__029152 = new BitSet(new long[]{0x0000000000000000L,0x0000000080800000L});

+    public static final BitSet FOLLOW_rule__AcceptStatement__Group__1_in_rule__AcceptStatement__Group__029155 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptStatement__ClauseAssignment_0_in_rule__AcceptStatement__Group__0__Impl29182 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptStatement__Group__1__Impl_in_rule__AcceptStatement__Group__129212 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptStatement__Alternatives_1_in_rule__AcceptStatement__Group__1__Impl29239 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SimpleAcceptStatementCompletion__Group__0__Impl_in_rule__SimpleAcceptStatementCompletion__Group__029273 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L});

+    public static final BitSet FOLLOW_rule__SimpleAcceptStatementCompletion__Group__1_in_rule__SimpleAcceptStatementCompletion__Group__029276 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SimpleAcceptStatementCompletion__Group__1__Impl_in_rule__SimpleAcceptStatementCompletion__Group__129334 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_95_in_rule__SimpleAcceptStatementCompletion__Group__1__Impl29362 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CompoundAcceptStatementCompletion__Group__0__Impl_in_rule__CompoundAcceptStatementCompletion__Group__029397 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});

+    public static final BitSet FOLLOW_rule__CompoundAcceptStatementCompletion__Group__1_in_rule__CompoundAcceptStatementCompletion__Group__029400 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CompoundAcceptStatementCompletion__BlockAssignment_0_in_rule__CompoundAcceptStatementCompletion__Group__0__Impl29427 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CompoundAcceptStatementCompletion__Group__1__Impl_in_rule__CompoundAcceptStatementCompletion__Group__129457 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CompoundAcceptStatementCompletion__Group_1__0_in_rule__CompoundAcceptStatementCompletion__Group__1__Impl29484 = new BitSet(new long[]{0x0000000000000002L,0x0000000800000000L});

+    public static final BitSet FOLLOW_rule__CompoundAcceptStatementCompletion__Group_1__0__Impl_in_rule__CompoundAcceptStatementCompletion__Group_1__029519 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});

+    public static final BitSet FOLLOW_rule__CompoundAcceptStatementCompletion__Group_1__1_in_rule__CompoundAcceptStatementCompletion__Group_1__029522 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_99_in_rule__CompoundAcceptStatementCompletion__Group_1__0__Impl29550 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CompoundAcceptStatementCompletion__Group_1__1__Impl_in_rule__CompoundAcceptStatementCompletion__Group_1__129581 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_1_in_rule__CompoundAcceptStatementCompletion__Group_1__1__Impl29608 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptBlock__Group__0__Impl_in_rule__AcceptBlock__Group__029642 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});

+    public static final BitSet FOLLOW_rule__AcceptBlock__Group__1_in_rule__AcceptBlock__Group__029645 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptBlock__ClauseAssignment_0_in_rule__AcceptBlock__Group__0__Impl29672 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptBlock__Group__1__Impl_in_rule__AcceptBlock__Group__129702 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptBlock__BlockAssignment_1_in_rule__AcceptBlock__Group__1__Impl29729 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group__0__Impl_in_rule__AcceptClause__Group__029763 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group__1_in_rule__AcceptClause__Group__029766 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_109_in_rule__AcceptClause__Group__0__Impl29794 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group__1__Impl_in_rule__AcceptClause__Group__129825 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group__2_in_rule__AcceptClause__Group__129828 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_68_in_rule__AcceptClause__Group__1__Impl29856 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group__2__Impl_in_rule__AcceptClause__Group__229887 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group__3_in_rule__AcceptClause__Group__229890 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group_2__0_in_rule__AcceptClause__Group__2__Impl29917 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group__3__Impl_in_rule__AcceptClause__Group__329948 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group__4_in_rule__AcceptClause__Group__329951 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptClause__QualifiedNameListAssignment_3_in_rule__AcceptClause__Group__3__Impl29978 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group__4__Impl_in_rule__AcceptClause__Group__430008 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_69_in_rule__AcceptClause__Group__4__Impl30036 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group_2__0__Impl_in_rule__AcceptClause__Group_2__030077 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group_2__1_in_rule__AcceptClause__Group_2__030080 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptClause__NameAssignment_2_0_in_rule__AcceptClause__Group_2__0__Impl30107 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AcceptClause__Group_2__1__Impl_in_rule__AcceptClause__Group_2__130137 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_71_in_rule__AcceptClause__Group_2__1__Impl30165 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassifyStatement__Group__0__Impl_in_rule__ClassifyStatement__Group__030200 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F80010L});

+    public static final BitSet FOLLOW_rule__ClassifyStatement__Group__1_in_rule__ClassifyStatement__Group__030203 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_110_in_rule__ClassifyStatement__Group__0__Impl30231 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassifyStatement__Group__1__Impl_in_rule__ClassifyStatement__Group__130262 = new BitSet(new long[]{0x0000000000000000L,0x0001800000000000L});

+    public static final BitSet FOLLOW_rule__ClassifyStatement__Group__2_in_rule__ClassifyStatement__Group__130265 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassifyStatement__ExpressionAssignment_1_in_rule__ClassifyStatement__Group__1__Impl30292 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassifyStatement__Group__2__Impl_in_rule__ClassifyStatement__Group__230322 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L});

+    public static final BitSet FOLLOW_rule__ClassifyStatement__Group__3_in_rule__ClassifyStatement__Group__230325 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassifyStatement__ClauseAssignment_2_in_rule__ClassifyStatement__Group__2__Impl30352 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassifyStatement__Group__3__Impl_in_rule__ClassifyStatement__Group__330382 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_95_in_rule__ClassifyStatement__Group__3__Impl30410 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationClause__Group_0__0__Impl_in_rule__ClassificationClause__Group_0__030449 = new BitSet(new long[]{0x0000000000000000L,0x0001800000000000L});

+    public static final BitSet FOLLOW_rule__ClassificationClause__Group_0__1_in_rule__ClassificationClause__Group_0__030452 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationClause__ClassifyFromClauseAssignment_0_0_in_rule__ClassificationClause__Group_0__0__Impl30479 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationClause__Group_0__1__Impl_in_rule__ClassificationClause__Group_0__130509 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationClause__ClassifyToClauseAssignment_0_1_in_rule__ClassificationClause__Group_0__1__Impl30536 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationClause__Group_1__0__Impl_in_rule__ClassificationClause__Group_1__030571 = new BitSet(new long[]{0x0000000000000000L,0x0001800000000000L});

+    public static final BitSet FOLLOW_rule__ClassificationClause__Group_1__1_in_rule__ClassificationClause__Group_1__030574 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationClause__ReclassyAllClauseAssignment_1_0_in_rule__ClassificationClause__Group_1__0__Impl30601 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationClause__Group_1__1__Impl_in_rule__ClassificationClause__Group_1__130632 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationClause__ClassifyToClauseAssignment_1_1_in_rule__ClassificationClause__Group_1__1__Impl30659 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationFromClause__Group__0__Impl_in_rule__ClassificationFromClause__Group__030693 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__ClassificationFromClause__Group__1_in_rule__ClassificationFromClause__Group__030696 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_111_in_rule__ClassificationFromClause__Group__0__Impl30724 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationFromClause__Group__1__Impl_in_rule__ClassificationFromClause__Group__130755 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationFromClause__QualifiedNameListAssignment_1_in_rule__ClassificationFromClause__Group__1__Impl30782 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationToClause__Group__0__Impl_in_rule__ClassificationToClause__Group__030816 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__ClassificationToClause__Group__1_in_rule__ClassificationToClause__Group__030819 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_112_in_rule__ClassificationToClause__Group__0__Impl30847 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationToClause__Group__1__Impl_in_rule__ClassificationToClause__Group__130878 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationToClause__QualifiedNameListAssignment_1_in_rule__ClassificationToClause__Group__1__Impl30905 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ReclassifyAllClause__Group__0__Impl_in_rule__ReclassifyAllClause__Group__030939 = new BitSet(new long[]{0x0000000000000000L,0x0000800000000000L});

+    public static final BitSet FOLLOW_rule__ReclassifyAllClause__Group__1_in_rule__ReclassifyAllClause__Group__030942 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ReclassifyAllClause__Group__1__Impl_in_rule__ReclassifyAllClause__Group__131000 = new BitSet(new long[]{0x0000000008000000L});

+    public static final BitSet FOLLOW_rule__ReclassifyAllClause__Group__2_in_rule__ReclassifyAllClause__Group__131003 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_111_in_rule__ReclassifyAllClause__Group__1__Impl31031 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ReclassifyAllClause__Group__2__Impl_in_rule__ReclassifyAllClause__Group__231062 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_27_in_rule__ReclassifyAllClause__Group__2__Impl31090 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameList__Group__0__Impl_in_rule__QualifiedNameList__Group__031127 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__QualifiedNameList__Group__1_in_rule__QualifiedNameList__Group__031130 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameList__QualifiedNameAssignment_0_in_rule__QualifiedNameList__Group__0__Impl31157 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameList__Group__1__Impl_in_rule__QualifiedNameList__Group__131187 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameList__Group_1__0_in_rule__QualifiedNameList__Group__1__Impl31214 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});

+    public static final BitSet FOLLOW_rule__QualifiedNameList__Group_1__0__Impl_in_rule__QualifiedNameList__Group_1__031249 = new BitSet(new long[]{0x0000000000000100L});

+    public static final BitSet FOLLOW_rule__QualifiedNameList__Group_1__1_in_rule__QualifiedNameList__Group_1__031252 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_66_in_rule__QualifiedNameList__Group_1__0__Impl31280 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameList__Group_1__1__Impl_in_rule__QualifiedNameList__Group_1__131311 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__QualifiedNameList__QualifiedNameAssignment_1_1_in_rule__QualifiedNameList__Group_1__1__Impl31338 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__031372 = new BitSet(new long[]{0x1FFE000000000100L,0x0000000080004000L});

+    public static final BitSet FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Group__1_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__031375 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_0_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__0__Impl31402 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__131432 = new BitSet(new long[]{0x1FFE000000000100L,0x0000000080004000L});

+    public static final BitSet FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Group__2_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__131435 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Alternatives_1_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__1__Impl31462 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__231493 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_95_in_rule__InvocationOrAssignementOrDeclarationStatement__Group__2__Impl31521 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationStatement__Group__0__Impl_in_rule__SuperInvocationStatement__Group__031558 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L});

+    public static final BitSet FOLLOW_rule__SuperInvocationStatement__Group__1_in_rule__SuperInvocationStatement__Group__031561 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationStatement___superAssignment_0_in_rule__SuperInvocationStatement__Group__0__Impl31588 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__SuperInvocationStatement__Group__1__Impl_in_rule__SuperInvocationStatement__Group__131618 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_95_in_rule__SuperInvocationStatement__Group__1__Impl31646 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ThisInvocationStatement__Group__0__Impl_in_rule__ThisInvocationStatement__Group__031681 = new BitSet(new long[]{0x1FFE000000000000L,0x0000000080000000L});

+    public static final BitSet FOLLOW_rule__ThisInvocationStatement__Group__1_in_rule__ThisInvocationStatement__Group__031684 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ThisInvocationStatement___thisAssignment_0_in_rule__ThisInvocationStatement__Group__0__Impl31711 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ThisInvocationStatement__Group__1__Impl_in_rule__ThisInvocationStatement__Group__131741 = new BitSet(new long[]{0x1FFE000000000000L,0x0000000080000000L});

+    public static final BitSet FOLLOW_rule__ThisInvocationStatement__Group__2_in_rule__ThisInvocationStatement__Group__131744 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ThisInvocationStatement__AssignmentCompletionAssignment_1_in_rule__ThisInvocationStatement__Group__1__Impl31771 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ThisInvocationStatement__Group__2__Impl_in_rule__ThisInvocationStatement__Group__231802 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_95_in_rule__ThisInvocationStatement__Group__2__Impl31830 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationInvocationStatement__Group__0__Impl_in_rule__InstanceCreationInvocationStatement__Group__031867 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L});

+    public static final BitSet FOLLOW_rule__InstanceCreationInvocationStatement__Group__1_in_rule__InstanceCreationInvocationStatement__Group__031870 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationInvocationStatement___newAssignment_0_in_rule__InstanceCreationInvocationStatement__Group__0__Impl31897 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__InstanceCreationInvocationStatement__Group__1__Impl_in_rule__InstanceCreationInvocationStatement__Group__131927 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_95_in_rule__InstanceCreationInvocationStatement__Group__1__Impl31955 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__VariableDeclarationCompletion__Group__0__Impl_in_rule__VariableDeclarationCompletion__Group__031990 = new BitSet(new long[]{0x0000000000000100L,0x0000000000004000L});

+    public static final BitSet FOLLOW_rule__VariableDeclarationCompletion__Group__1_in_rule__VariableDeclarationCompletion__Group__031993 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__VariableDeclarationCompletion__Group_0__0_in_rule__VariableDeclarationCompletion__Group__0__Impl32020 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__VariableDeclarationCompletion__Group__1__Impl_in_rule__VariableDeclarationCompletion__Group__132051 = new BitSet(new long[]{0x1FFE000000000000L});

+    public static final BitSet FOLLOW_rule__VariableDeclarationCompletion__Group__2_in_rule__VariableDeclarationCompletion__Group__132054 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__VariableDeclarationCompletion__VariableNameAssignment_1_in_rule__VariableDeclarationCompletion__Group__1__Impl32081 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__VariableDeclarationCompletion__Group__2__Impl_in_rule__VariableDeclarationCompletion__Group__232111 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__VariableDeclarationCompletion__InitValueAssignment_2_in_rule__VariableDeclarationCompletion__Group__2__Impl32138 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__VariableDeclarationCompletion__Group_0__0__Impl_in_rule__VariableDeclarationCompletion__Group_0__032174 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});

+    public static final BitSet FOLLOW_rule__VariableDeclarationCompletion__Group_0__1_in_rule__VariableDeclarationCompletion__Group_0__032177 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_0_in_rule__VariableDeclarationCompletion__Group_0__0__Impl32204 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__VariableDeclarationCompletion__Group_0__1__Impl_in_rule__VariableDeclarationCompletion__Group_0__132234 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_79_in_rule__VariableDeclarationCompletion__Group_0__1__Impl32262 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AssignmentCompletion__Group__0__Impl_in_rule__AssignmentCompletion__Group__032297 = new BitSet(new long[]{0x00000007CE0031F0L,0x00007B93C8F84010L});

+    public static final BitSet FOLLOW_rule__AssignmentCompletion__Group__1_in_rule__AssignmentCompletion__Group__032300 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AssignmentCompletion__OpAssignment_0_in_rule__AssignmentCompletion__Group__0__Impl32327 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AssignmentCompletion__Group__1__Impl_in_rule__AssignmentCompletion__Group__132357 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AssignmentCompletion__RightHandSideAssignment_1_in_rule__AssignmentCompletion__Group__1__Impl32384 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__Test__ExpressionAssignment_0_132423 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAssignmentCompletion_in_rule__Test__AssignExpressionAssignment_1_132454 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleStatement_in_rule__Test__StatementsAssignment_2_132485 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBlock_in_rule__Test__BlockAssignment_3_132516 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBooleanValue_in_rule__BOOLEAN_LITERAL__ValueAssignment32547 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_INTEGERVALUE_in_rule__INTEGER_LITERAL__ValueAssignment32578 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_27_in_rule__UNLIMITED_LITERAL__ValueAssignment32614 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_STRING_in_rule__STRING_LITERAL__ValueAssignment32653 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__PrefixOpAlternatives_0_0_0_0_in_rule__NameExpression__PrefixOpAssignment_0_0_032684 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNamePath_in_rule__NameExpression__PathAssignment_0_0_132717 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__NameExpression__IdAssignment_0_0_232748 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNamePath_in_rule__NameExpression__PathAssignment_0_1_032779 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__NameExpression__IdAssignment_0_1_132810 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleTuple_in_rule__NameExpression__InvocationCompletionAssignment_0_1_2_032841 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceConstructionOrAccessCompletion_in_rule__NameExpression__SequenceConstructionCompletionAssignment_0_1_2_132872 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__NameExpression__PostfixOpAlternatives_0_1_2_2_0_in_rule__NameExpression__PostfixOpAssignment_0_1_2_232903 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuffixExpression_in_rule__NameExpression__SuffixAssignment_132936 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleUnqualifiedName_in_rule__QualifiedNamePath__NamespaceAssignment_032967 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__UnqualifiedName__NameAssignment_032998 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleTemplateBinding_in_rule__UnqualifiedName__TemplateBindingAssignment_133029 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNamedTemplateBinding_in_rule__TemplateBinding__BindingsAssignment_133060 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNamedTemplateBinding_in_rule__TemplateBinding__BindingsAssignment_2_133091 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__NamedTemplateBinding__FormalAssignment_033122 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameWithBinding_in_rule__NamedTemplateBinding__ActualAssignment_233153 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__QualifiedNameWithBinding__IdAssignment_033184 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleTemplateBinding_in_rule__QualifiedNameWithBinding__BindingAssignment_133215 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameWithBinding_in_rule__QualifiedNameWithBinding__RemainingAssignment_2_133246 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleTupleElement_in_rule__Tuple__TupleElementsAssignment_2_033277 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleTupleElement_in_rule__Tuple__TupleElementsAssignment_2_1_133308 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__TupleElement__ArgumentAssignment33339 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleConditionalOrExpression_in_rule__ConditionalTestExpression__ExpAssignment_033370 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleConditionalTestExpression_in_rule__ConditionalTestExpression__WhenTrueAssignment_1_133401 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleConditionalTestExpression_in_rule__ConditionalTestExpression__WhenFalseAssignment_1_333432 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleConditionalAndExpression_in_rule__ConditionalOrExpression__ExpAssignment_033463 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleConditionalAndExpression_in_rule__ConditionalOrExpression__ExpAssignment_1_133494 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInclusiveOrExpression_in_rule__ConditionalAndExpression__ExpAssignment_033525 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInclusiveOrExpression_in_rule__ConditionalAndExpression__ExpAssignment_1_133556 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExclusiveOrExpression_in_rule__InclusiveOrExpression__ExpAssignment_033587 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExclusiveOrExpression_in_rule__InclusiveOrExpression__ExpAssignment_1_133618 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAndExpression_in_rule__ExclusiveOrExpression__ExpAssignment_033649 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAndExpression_in_rule__ExclusiveOrExpression__ExpAssignment_1_133680 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleEqualityExpression_in_rule__AndExpression__ExpAssignment_033711 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleEqualityExpression_in_rule__AndExpression__ExpAssignment_1_133742 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassificationExpression_in_rule__EqualityExpression__ExpAssignment_033773 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__EqualityExpression__OpAlternatives_1_0_0_in_rule__EqualityExpression__OpAssignment_1_033804 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassificationExpression_in_rule__EqualityExpression__ExpAssignment_1_133837 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleRelationalExpression_in_rule__ClassificationExpression__ExpAssignment_033868 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ClassificationExpression__OpAlternatives_1_0_0_in_rule__ClassificationExpression__OpAssignment_1_033899 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNameExpression_in_rule__ClassificationExpression__TypeNameAssignment_1_133932 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleShiftExpression_in_rule__RelationalExpression__LeftAssignment_033963 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__RelationalExpression__OpAlternatives_1_0_0_in_rule__RelationalExpression__OpAssignment_1_033994 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleShiftExpression_in_rule__RelationalExpression__RightAssignment_1_134027 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAdditiveExpression_in_rule__ShiftExpression__ExpAssignment_034058 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__ShiftExpression__OpAlternatives_1_0_0_in_rule__ShiftExpression__OpAssignment_1_034089 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAdditiveExpression_in_rule__ShiftExpression__ExpAssignment_1_134122 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleMultiplicativeExpression_in_rule__AdditiveExpression__ExpAssignment_034153 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__AdditiveExpression__OpAlternatives_1_0_0_in_rule__AdditiveExpression__OpAssignment_1_034184 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleMultiplicativeExpression_in_rule__AdditiveExpression__ExpAssignment_1_134217 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleUnaryExpression_in_rule__MultiplicativeExpression__ExpAssignment_034248 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__MultiplicativeExpression__OpAlternatives_1_0_0_in_rule__MultiplicativeExpression__OpAssignment_1_034279 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleUnaryExpression_in_rule__MultiplicativeExpression__ExpAssignment_1_134312 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__UnaryExpression__OpAlternatives_0_0_in_rule__UnaryExpression__OpAssignment_034343 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rulePrimaryExpression_in_rule__UnaryExpression__ExpAssignment_134376 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleValueSpecification_in_rule__PrimaryExpression__PrefixAssignment34407 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__OperationCallExpression__OperationNameAssignment_134438 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleTuple_in_rule__OperationCallExpression__TupleAssignment_234469 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuffixExpression_in_rule__OperationCallExpression__SuffixAssignment_334500 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__PropertyCallExpression__PropertyNameAssignment_134531 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__PropertyCallExpression__IndexAssignment_2_134562 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuffixExpression_in_rule__PropertyCallExpression__SuffixAssignment_334593 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLinkOperationKind_in_rule__LinkOperationExpression__KindAssignment_134624 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLinkOperationTuple_in_rule__LinkOperationExpression__TupleAssignment_234655 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLinkOperationTupleElement_in_rule__LinkOperationTuple__LinkOperationTupleElementAssignment_134686 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLinkOperationTupleElement_in_rule__LinkOperationTuple__LinkOperationTupleElementAssignment_2_134717 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__LinkOperationTupleElement__RoleAssignment_034748 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__LinkOperationTupleElement__RoleIndexAssignment_1_134779 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__LinkOperationTupleElement__ObjectAssignment_334810 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameWithBinding_in_rule__SequenceOperationExpression__OperationNameAssignment_134841 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleTuple_in_rule__SequenceOperationExpression__TupleAssignment_234872 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuffixExpression_in_rule__SequenceOperationExpression__SuffixAssignment_334903 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_113_in_rule__SequenceReductionExpression__IsOrderedAssignment_234939 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameWithBinding_in_rule__SequenceReductionExpression__BehaviorAssignment_334978 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuffixExpression_in_rule__SequenceReductionExpression__SuffixAssignment_435009 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSelectOrRejectOperator_in_rule__SelectOrRejectOperation__OpAssignment_135040 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__SelectOrRejectOperation__NameAssignment_235071 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__SelectOrRejectOperation__ExprAssignment_435102 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuffixExpression_in_rule__SelectOrRejectOperation__SuffixAssignment_635133 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleCollectOrIterateOperator_in_rule__CollectOrIterateOperation__OpAssignment_135164 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__CollectOrIterateOperation__NameAssignment_235195 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__CollectOrIterateOperation__ExprAssignment_435226 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuffixExpression_in_rule__CollectOrIterateOperation__SuffixAssignment_635257 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleForAllOrExistsOrOneOperator_in_rule__ForAllOrExistsOrOneOperation__OpAssignment_135288 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__ForAllOrExistsOrOneOperation__NameAssignment_235319 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__ForAllOrExistsOrOneOperation__ExprAssignment_435350 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuffixExpression_in_rule__ForAllOrExistsOrOneOperation__SuffixAssignment_635381 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__IsUniqueOperation__NameAssignment_235412 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__IsUniqueOperation__ExprAssignment_435443 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuffixExpression_in_rule__IsUniqueOperation__SuffixAssignment_635474 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__ParenthesizedExpression__ExpOrTypeCastAssignment_135505 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNonLiteralValueSpecification_in_rule__ParenthesizedExpression__CastedAssignment_3_035536 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuffixExpression_in_rule__ParenthesizedExpression__SuffixAssignment_3_135567 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuffixExpression_in_rule__ThisExpression__SuffixAssignment_235598 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleTuple_in_rule__SuperInvocationExpression__TupleAssignment_1_035629 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameWithBinding_in_rule__SuperInvocationExpression__OperationNameAssignment_1_1_135660 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleTuple_in_rule__SuperInvocationExpression__TupleAssignment_1_1_235691 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameWithBinding_in_rule__InstanceCreationExpression__ConstructorAssignment_135722 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInstanceCreationTuple_in_rule__InstanceCreationExpression__TupleAssignment_235753 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuffixExpression_in_rule__InstanceCreationExpression__SuffixAssignment_335784 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInstanceCreationTupleElement_in_rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_035815 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInstanceCreationTupleElement_in_rule__InstanceCreationTuple__InstanceCreationTupleElementAssignment_2_1_135846 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__InstanceCreationTupleElement__RoleAssignment_035877 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__InstanceCreationTupleElement__ObjectAssignment_235908 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_78_in_rule__SequenceConstructionOrAccessCompletion__MultiplicityIndicatorAssignment_0_035944 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAccessCompletion_in_rule__SequenceConstructionOrAccessCompletion__AccessCompletionAssignment_0_1_035983 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rulePartialSequenceConstructionCompletion_in_rule__SequenceConstructionOrAccessCompletion__SequenceCompletionAssignment_0_1_136014 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceConstructionExpression_in_rule__SequenceConstructionOrAccessCompletion__ExpressionAssignment_136045 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__AccessCompletion__AccessIndexAssignment_036076 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceConstructionExpression_in_rule__PartialSequenceConstructionCompletion__ExpressionAssignment_136107 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceElement_in_rule__SequenceConstructionExpression__SequenceElementAssignment_136138 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceElement_in_rule__SequenceConstructionExpression__SequenceElementAssignment_2_0_136169 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__SequenceConstructionExpression__RangeUpperAssignment_2_1_136200 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleStatementSequence_in_rule__Block__SequenceAssignment_236231 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleDocumentedStatement_in_rule__StatementSequence__StatementsAssignment36262 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_rule__DocumentedStatement__CommentAlternatives_0_0_in_rule__DocumentedStatement__CommentAssignment_036293 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleStatement_in_rule__DocumentedStatement__StatementAssignment_136326 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__InlineStatement__LangageNameAssignment_336357 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_STRING_in_rule__InlineStatement__BodyAssignment_536388 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAnnotation_in_rule__AnnotatedStatement__AnnotationAssignment_136419 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleStatement_in_rule__AnnotatedStatement__StatementAssignment_236450 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAnnotationKind_in_rule__Annotation__KindAssignment_036481 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__Annotation__ArgsAssignment_1_136512 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__Annotation__ArgsAssignment_1_2_136543 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBlock_in_rule__BlockStatement__BlockAssignment36574 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__LocalNameDeclarationStatement__VarNameAssignment_136605 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameWithBinding_in_rule__LocalNameDeclarationStatement__TypeAssignment_336636 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_78_in_rule__LocalNameDeclarationStatement__MultiplicityIndicatorAssignment_4_036672 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceElement_in_rule__LocalNameDeclarationStatement__InitAssignment_636711 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequentialClauses_in_rule__IfStatement__SequentialClaussesAssignment_136742 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleFinalClause_in_rule__IfStatement__FinalClauseAssignment_236773 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleConcurrentClauses_in_rule__SequentialClauses__ConccurentClausesAssignment_036804 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleConcurrentClauses_in_rule__SequentialClauses__ConccurentClausesAssignment_1_236835 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNonFinalClause_in_rule__ConcurrentClauses__NonFinalClauseAssignment_036866 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNonFinalClause_in_rule__ConcurrentClauses__NonFinalClauseAssignment_1_236897 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__NonFinalClause__ConditionAssignment_136928 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBlock_in_rule__NonFinalClause__BlockAssignment_336959 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBlock_in_rule__FinalClause__BlockAssignment_136990 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__SwitchStatement__ExpressionAssignment_237021 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSwitchClause_in_rule__SwitchStatement__SwitchClauseAssignment_537052 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSwitchDefaultClause_in_rule__SwitchStatement__DefaultClauseAssignment_637083 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSwitchCase_in_rule__SwitchClause__SwitchCaseAssignment_037114 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSwitchCase_in_rule__SwitchClause__SwitchCaseAssignment_137145 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNonEmptyStatementSequence_in_rule__SwitchClause__StatementSequenceAssignment_237176 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__SwitchCase__ExpressionAssignment_137207 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNonEmptyStatementSequence_in_rule__SwitchDefaultClause__StatementSequenceAssignment_237238 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleDocumentedStatement_in_rule__NonEmptyStatementSequence__StatementAssignment37269 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__WhileStatement__ConditionAssignment_237300 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBlock_in_rule__WhileStatement__BlockAssignment_437331 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBlock_in_rule__DoStatement__BlockAssignment_137362 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__DoStatement__ConditionAssignment_437393 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleForControl_in_rule__ForStatement__ControlAssignment_237424 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBlock_in_rule__ForStatement__BlockAssignment_437455 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLoopVariableDefinition_in_rule__ForControl__LoopVariableDefinitionAssignment_037486 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleLoopVariableDefinition_in_rule__ForControl__LoopVariableDefinitionAssignment_1_137517 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__LoopVariableDefinition__NameAssignment_0_037548 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__LoopVariableDefinition__Expression1Assignment_0_237579 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__LoopVariableDefinition__Expression2Assignment_0_3_137610 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameWithBinding_in_rule__LoopVariableDefinition__TypeAssignment_1_037641 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__LoopVariableDefinition__NameAssignment_1_137672 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__LoopVariableDefinition__ExpressionAssignment_1_337703 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__ReturnStatement__ExpressionAssignment_137734 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAcceptClause_in_rule__AcceptStatement__ClauseAssignment_037765 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSimpleAcceptStatementCompletion_in_rule__AcceptStatement__SimpleAcceptAssignment_1_037796 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleCompoundAcceptStatementCompletion_in_rule__AcceptStatement__CompoundAcceptAssignment_1_137827 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBlock_in_rule__CompoundAcceptStatementCompletion__BlockAssignment_037858 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAcceptBlock_in_rule__CompoundAcceptStatementCompletion__AcceptBlockAssignment_1_137889 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAcceptClause_in_rule__AcceptBlock__ClauseAssignment_037920 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleBlock_in_rule__AcceptBlock__BlockAssignment_137951 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__AcceptClause__NameAssignment_2_037982 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameList_in_rule__AcceptClause__QualifiedNameListAssignment_338013 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleExpression_in_rule__ClassifyStatement__ExpressionAssignment_138044 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassificationClause_in_rule__ClassifyStatement__ClauseAssignment_238075 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassificationFromClause_in_rule__ClassificationClause__ClassifyFromClauseAssignment_0_038106 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassificationToClause_in_rule__ClassificationClause__ClassifyToClauseAssignment_0_138137 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleReclassifyAllClause_in_rule__ClassificationClause__ReclassyAllClauseAssignment_1_038168 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleClassificationToClause_in_rule__ClassificationClause__ClassifyToClauseAssignment_1_138199 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameList_in_rule__ClassificationFromClause__QualifiedNameListAssignment_138230 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameList_in_rule__ClassificationToClause__QualifiedNameListAssignment_138261 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameWithBinding_in_rule__QualifiedNameList__QualifiedNameAssignment_038292 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleQualifiedNameWithBinding_in_rule__QualifiedNameList__QualifiedNameAssignment_1_138323 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleNameExpression_in_rule__InvocationOrAssignementOrDeclarationStatement__TypePart_OR_assignedPart_OR_invocationPartAssignment_038354 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleVariableDeclarationCompletion_in_rule__InvocationOrAssignementOrDeclarationStatement__VariableDeclarationCompletionAssignment_1_038385 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAssignmentCompletion_in_rule__InvocationOrAssignementOrDeclarationStatement__AssignmentCompletionAssignment_1_138416 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSuperInvocationExpression_in_rule__SuperInvocationStatement___superAssignment_038447 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleThisExpression_in_rule__ThisInvocationStatement___thisAssignment_038478 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAssignmentCompletion_in_rule__ThisInvocationStatement__AssignmentCompletionAssignment_138509 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleInstanceCreationExpression_in_rule__InstanceCreationInvocationStatement___newAssignment_038540 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_78_in_rule__VariableDeclarationCompletion__MultiplicityIndicatorAssignment_0_038576 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_RULE_ID_in_rule__VariableDeclarationCompletion__VariableNameAssignment_138615 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAssignmentCompletion_in_rule__VariableDeclarationCompletion__InitValueAssignment_238646 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleAssignmentOperator_in_rule__AssignmentCompletion__OpAssignment_038677 = new BitSet(new long[]{0x0000000000000002L});

+    public static final BitSet FOLLOW_ruleSequenceElement_in_rule__AssignmentCompletion__RightHandSideAssignment_138708 = new BitSet(new long[]{0x0000000000000002L});

+

+}
\ No newline at end of file
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/internal/AlfActivator.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/internal/AlfActivator.java
new file mode 100644
index 00000000000..bf14e2e49d1
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src-gen/org/eclipse/papyrus/alf/ui/internal/AlfActivator.java
@@ -0,0 +1,82 @@
+/*
+ * generated by Xtext
+ */
+package org.eclipse.papyrus.alf.ui.internal;
+
+import static com.google.inject.util.Modules.override;
+import static com.google.inject.Guice.createInjector;
+
+import org.apache.log4j.Logger;
+
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.osgi.framework.BundleContext;
+
+import com.google.inject.Injector;
+import com.google.inject.Module;
+
+import java.util.Map;
+import java.util.HashMap;
+
+/**
+ * This class was generated. Customizations should only happen in a newly
+ * introduced subclass. 
+ */
+public class AlfActivator extends AbstractUIPlugin {
+
+	private Map<String,Injector> injectors = new HashMap<String,Injector>();
+	private static AlfActivator INSTANCE;
+
+	public Injector getInjector(String languageName) {
+		return injectors.get(languageName);
+	}
+	
+	@Override
+	public void start(BundleContext context) throws Exception {
+		super.start(context);
+		INSTANCE = this;
+		try {
+			registerInjectorFor("org.eclipse.papyrus.alf.Alf");
+			
+		} catch (Exception e) {
+			Logger.getLogger(getClass()).error(e.getMessage(), e);
+			throw e;
+		}
+	}
+	
+	protected void registerInjectorFor(String language) throws Exception {
+		injectors.put(language, createInjector(
+		  override(override(getRuntimeModule(language)).with(getSharedStateModule())).with(getUiModule(language))));
+	}
+	
+	@Override
+	public void stop(BundleContext context) throws Exception {
+		injectors.clear();
+		INSTANCE = null;
+		super.stop(context);
+	}
+	
+	public static AlfActivator getInstance() {
+		return INSTANCE;
+	}
+	
+	protected Module getRuntimeModule(String grammar) {
+		if ("org.eclipse.papyrus.alf.Alf".equals(grammar)) {
+		  return new org.eclipse.papyrus.alf.AlfRuntimeModule();
+		}
+		
+		throw new IllegalArgumentException(grammar);
+	}
+	
+	protected Module getUiModule(String grammar) {
+		if ("org.eclipse.papyrus.alf.Alf".equals(grammar)) {
+		  return new org.eclipse.papyrus.alf.ui.AlfUiModule(this);
+		}
+		
+		throw new IllegalArgumentException(grammar);
+	}
+	
+	protected Module getSharedStateModule() {
+		return new org.eclipse.xtext.ui.shared.SharedStateModule();
+	}
+	
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/AlfUiModule.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/AlfUiModule.java
new file mode 100644
index 00000000000..ad2dfc3d7a1
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/AlfUiModule.java
@@ -0,0 +1,25 @@
+/*****************************************************************************
+ * Copyright (c) 2010 CEA LIST.
+ *
+ *    
+ * 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:
+ *  CEA LIST - Initial API and implementation
+ *
+ *****************************************************************************/
+package org.eclipse.papyrus.alf.ui;
+
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+
+/**
+ * Use this class to register components to be used within the IDE.
+ */
+public class AlfUiModule extends org.eclipse.papyrus.alf.ui.AbstractAlfUiModule {
+	public AlfUiModule(AbstractUIPlugin plugin) {
+		super(plugin);
+	}
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/contentassist/AlfProposalProvider.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/contentassist/AlfProposalProvider.java
new file mode 100644
index 00000000000..940d1247a2d
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/contentassist/AlfProposalProvider.java
@@ -0,0 +1,180 @@
+/*****************************************************************************
+ * Copyright (c) 2010 CEA LIST.
+ *
+ *    
+ * 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:
+ *  CEA LIST - Initial API and implementation
+ *
+ *****************************************************************************/
+package org.eclipse.papyrus.alf.ui.contentassist;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.jface.text.contentassist.ICompletionProposal;
+import org.eclipse.papyrus.alf.alf.NameExpression;
+import org.eclipse.papyrus.alf.alf.PropertyCallExpression;
+import org.eclipse.papyrus.alf.alf.SuffixExpression;
+import org.eclipse.papyrus.alf.scoping.AlfScopingTool;
+import org.eclipse.papyrus.alf.scoping.AlfPartialScope;
+import org.eclipse.papyrus.alf.scoping.AlfScopeProvider;
+import org.eclipse.papyrus.alf.ui.contentassist.AbstractAlfProposalProvider;
+import org.eclipse.papyrus.alf.validation.AlfJavaValidator;
+import org.eclipse.papyrus.alf.validation.typing.ErrorTypeFacade;
+import org.eclipse.papyrus.alf.validation.typing.SignatureFacadeFactory;
+import org.eclipse.papyrus.alf.validation.typing.TypeExpression;
+import org.eclipse.papyrus.alf.validation.typing.TypeFacade;
+import org.eclipse.papyrus.alf.validation.typing.TypeUtils;
+import org.eclipse.uml2.uml.Classifier;
+import org.eclipse.uml2.uml.Operation;
+import org.eclipse.uml2.uml.Property;
+import org.eclipse.xtext.Assignment;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.gmf.glue.contentassist.CompletionProposalUtils;
+import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext;
+import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor;
+/**
+ * see http://www.eclipse.org/Xtext/documentation/latest/xtext.html#contentAssist on how to customize content assistant
+ */
+public class AlfProposalProvider extends AbstractAlfProposalProvider {
+	
+	
+	@Override
+	public void completeLocalNameDeclarationStatement_Type(EObject model,
+			Assignment assignment, ContentAssistContext context,
+			ICompletionProposalAcceptor acceptor) {
+		// TODO Auto-generated method stub
+		AlfPartialScope scope = AlfScopeProvider.scopingTool.getVisibleClassifiers(model) ;
+		new AlfCompletionProposalUtils().classifierProposals(scope, context, acceptor) ;
+		super.completeLocalNameDeclarationStatement_Type(model, assignment, context,
+				acceptor);
+	}
+
+	@Override
+	public void completeOperationCallExpression_OperationName(EObject model,
+			Assignment assignment, ContentAssistContext context,
+			ICompletionProposalAcceptor acceptor) {
+		TypeExpression typeOfModel = null ;
+		if (model instanceof SuffixExpression) {
+			if (context.getPrefix().equals(""))
+				typeOfModel = new TypeUtils().getTypeOfCandidateExpression(model) ;
+			else
+				typeOfModel = new TypeUtils((SuffixExpression)model).getTypeOfCandidateExpression(model.eContainer()) ;
+		}
+		else {
+			typeOfModel = new TypeUtils().getTypeOfCandidateExpression(model) ;
+		}
+		if (typeOfModel == null || typeOfModel.getTypeFacade() instanceof ErrorTypeFacade)
+			super.completeOperationCallExpression_OperationName(model, assignment, context,
+				acceptor);
+		else {
+			new AlfCompletionProposalUtils().operationProposals(typeOfModel.getTypeFacade(), context, acceptor) ;
+			super.completeOperationCallExpression_OperationName(model, assignment, context,	acceptor);
+		}
+	}
+	
+
+	@Override
+	public void completePropertyCallExpression_PropertyName(EObject model,
+			Assignment assignment, ContentAssistContext context,
+			ICompletionProposalAcceptor acceptor) {
+		TypeExpression typeOfModel = null ;
+		if (model instanceof SuffixExpression) {
+			if (context.getPrefix().equals(""))
+				typeOfModel = new TypeUtils().getTypeOfCandidateExpression(model) ;
+			else
+				typeOfModel = new TypeUtils((SuffixExpression)model).getTypeOfCandidateExpression(model.eContainer()) ;
+		}
+		else {
+			typeOfModel = new TypeUtils().getTypeOfCandidateExpression(model) ;
+		}
+		if (typeOfModel == null || typeOfModel.getTypeFacade() instanceof ErrorTypeFacade)
+			super.completePropertyCallExpression_PropertyName(model, assignment, context,
+				acceptor);
+		else {
+			new AlfCompletionProposalUtils().propertyProposals(typeOfModel.getTypeFacade(), context, acceptor) ;
+			super.completePropertyCallExpression_PropertyName(model, assignment, context, acceptor);
+		}
+	}
+
+	
+	/**************************
+	 * 
+	 * Completion proposal utils
+	 *
+	 */
+	private class AlfCompletionProposalUtils {
+		
+		public void classifierProposals(AlfPartialScope scope, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+			for (List<EObject> scopingLevel : scope.getScopeDetails()) {
+				String completionString = "" ;
+				String displayString = "" ;
+				Map<String, ICompletionProposal> completionProposals = new HashMap<String, ICompletionProposal>() ;
+				ICompletionProposal proposal = null ;
+				for (EObject visibleClassifier : scopingLevel) {					
+					completionString = scope.getElementName(visibleClassifier) ;
+					displayString = "" + completionString ;
+					if (completionString.startsWith(context.getPrefix())) {
+						completionString = completionString.substring(context.getPrefix().length()) ;
+						if (completionProposals.get(displayString)==null) {
+							completionProposals.put(displayString, proposal) ;
+							proposal = CompletionProposalUtils.createCompletionProposal(completionString, displayString, context) ;
+							acceptor.accept(proposal) ;
+						}
+					}
+				}
+			}
+		}
+		
+		public void operationProposals(TypeFacade f, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+			Classifier c = f.extractActualType() ;
+			String completionString = "" ;
+			String displayString = "" ;
+			Map<String, ICompletionProposal> completionProposals = new HashMap<String, ICompletionProposal>() ;
+			ICompletionProposal proposal = null ;
+			for (Operation o : c.getAllOperations()) {
+				completionString = SignatureFacadeFactory.eInstance.createSignatureFacade(o).getLabel() ;
+				displayString = "" + completionString ;
+				if (completionString.startsWith(context.getPrefix())) {
+					completionString = completionString.substring(context.getPrefix().length()) ;
+					if (completionProposals.get(displayString)==null) {
+						completionProposals.put(displayString, proposal) ;
+						proposal = CompletionProposalUtils.createCompletionProposal(completionString, displayString, context) ;
+						acceptor.accept(proposal) ;
+					}
+				}
+			}
+		}
+		
+		public void propertyProposals(TypeFacade f, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+			Classifier c = f.extractActualType() ;
+			String completionString = "" ;
+			String displayString = "" ;
+			Map<String, ICompletionProposal> completionProposals = new HashMap<String, ICompletionProposal>() ;
+			ICompletionProposal proposal = null ;
+			for (Property p : c.getAllAttributes()) {
+				displayString = p.getName() + " : " + (p.getType() == null ? "any" : p.getType().getName()) ;
+				completionString = p.getName() ;
+				if (completionString.startsWith(context.getPrefix())) {
+					completionString = completionString.substring(context.getPrefix().length()) ;
+					if (completionProposals.get(displayString)==null) {
+						completionProposals.put(displayString, proposal) ;
+						proposal = CompletionProposalUtils.createCompletionProposal(completionString, displayString, context) ;
+						acceptor.accept(proposal) ;
+					}
+				}
+			}
+		}
+	}
+	
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/labeling/AlfDescriptionLabelProvider.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/labeling/AlfDescriptionLabelProvider.java
new file mode 100644
index 00000000000..c607c44797e
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/labeling/AlfDescriptionLabelProvider.java
@@ -0,0 +1,37 @@
+/*****************************************************************************
+ * Copyright (c) 2010 CEA LIST.
+ *
+ *    
+ * 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:
+ *  CEA LIST - Initial API and implementation
+ *
+ *****************************************************************************/
+package org.eclipse.papyrus.alf.ui.labeling;
+
+import org.eclipse.xtext.ui.label.DefaultDescriptionLabelProvider;
+
+/**
+ * Provides labels for a IEObjectDescriptions and IResourceDescriptions.
+ * 
+ * see http://www.eclipse.org/Xtext/documentation/latest/xtext.html#labelProvider
+ */
+public class AlfDescriptionLabelProvider extends DefaultDescriptionLabelProvider {
+
+/*
+	//Labels and icons can be computed like this:
+	
+	String text(IEObjectDescription ele) {
+	  return "my "+ele.getName();
+	}
+	 
+    String image(IEObjectDescription ele) {
+      return ele.getEClass().getName() + ".gif";
+    }	 
+*/
+
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/labeling/AlfLabelProvider.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/labeling/AlfLabelProvider.java
new file mode 100644
index 00000000000..114d2591346
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/labeling/AlfLabelProvider.java
@@ -0,0 +1,44 @@
+/*****************************************************************************
+ * Copyright (c) 2010 CEA LIST.
+ *
+ *    
+ * 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:
+ *  CEA LIST - Initial API and implementation
+ *
+ *****************************************************************************/
+package org.eclipse.papyrus.alf.ui.labeling;
+
+import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
+import org.eclipse.xtext.ui.label.DefaultEObjectLabelProvider;
+
+import com.google.inject.Inject;
+
+/**
+ * Provides labels for a EObjects.
+ * 
+ * see http://www.eclipse.org/Xtext/documentation/latest/xtext.html#labelProvider
+ */
+public class AlfLabelProvider extends DefaultEObjectLabelProvider {
+
+	@Inject
+	public AlfLabelProvider(AdapterFactoryLabelProvider delegate) {
+		super(delegate);
+	}
+
+/*
+	//Labels and icons can be computed like this:
+	
+	String text(MyModel ele) {
+	  return "my "+ele.getName();
+	}
+	 
+    String image(MyModel ele) {
+      return "MyModel.gif";
+    }
+*/
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/outline/AlfOutlineTreeProvider.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/outline/AlfOutlineTreeProvider.java
new file mode 100644
index 00000000000..f5a071c141e
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/outline/AlfOutlineTreeProvider.java
@@ -0,0 +1,14 @@
+/*
+* generated by Xtext
+*/
+package org.eclipse.papyrus.alf.ui.outline;
+
+import org.eclipse.xtext.ui.editor.outline.impl.DefaultOutlineTreeProvider;
+
+/**
+ * customization of the default outline structure
+ * 
+ */
+public class AlfOutlineTreeProvider extends DefaultOutlineTreeProvider {
+	
+}
diff --git a/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/quickfix/AlfQuickfixProvider.java b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/quickfix/AlfQuickfixProvider.java
new file mode 100644
index 00000000000..84973861d52
--- /dev/null
+++ b/extraplugins/alf09/org.eclipse.papyrus.alf.ui/src/org/eclipse/papyrus/alf/ui/quickfix/AlfQuickfixProvider.java
@@ -0,0 +1,32 @@
+/*****************************************************************************
+ * Copyright (c) 2010 CEA LIST.
+ *
+ *    
+ * 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:
+ *  CEA LIST - Initial API and implementation
+ *
+ *****************************************************************************/
+
+package org.eclipse.papyrus.alf.ui.quickfix;
+
+import org.eclipse.xtext.ui.editor.quickfix.DefaultQuickfixProvider;
+
+public class AlfQuickfixProvider extends DefaultQuickfixProvider {
+
+//	@Fix(MyJavaValidator.INVALID_NAME)
+//	public void capitalizeName(final Issue issue, IssueResolutionAcceptor acceptor) {
+//		acceptor.accept(issue, "Capitalize name", "Capitalize the name.", "upcase.png", new IModification() {
+//			public void apply(IModificationContext context) throws BadLocationException {
+//				IXtextDocument xtextDocument = context.getXtextDocument();
+//				String firstLetter = xtextDocument.get(issue.getOffset(), 1);
+//				xtextDocument.replace(issue.getOffset(), 1, firstLetter.toUpperCase());
+//			}
+//		});
+//	}
+
+}